Socket sendto() fails errno 88 and 9 - sockets

Question

I'm trying to run a simple client-server application using UDP (as an exercise), OS Linux Mint 14.
Client sends a request to the server, when starting, to get a few session parameters, including a timeout in usec.
The client opens a socket and sets a default timeout value, in order non to be blocked indefinetly on recvfrom, then sends a request for those parameters, closes said socket, re-opens a socket setting the new timeout value, and finally asks the user for commands.
The parameters request is dealt with by a subfunction which gets, among other things, a pointer to the client socket, so that the main function will be able to reference the new socket as well, should the new sockfd be a different number.
(Return value is used as a check value, zero or non-zero)
The sequence is:
client calls for subfunction passing socket pointer
subfunction sends request
subfunction gets answer
subfunction closes old socket
subfunction opens new socket (socket(), setsockopt, bind()) on the location pointed by the socket pointer (thus replacing the original)
- Problem
next call to sendto() fails either with errno 9 (bad file number) or with errno 88 (socket operation on non-socket).
Call to function in main: (servaddr is a struct sockaddr_in, hence the cast; sockfd is an int)
int checkParameters;
checkParameters=clientrequest(&sockfd, (struct sockaddr*) &servaddr, 0, settings);
clientrequest() description:
int clientparameters(int* socketpt, struct sockaddr* remaddr, unsigned int parameters[])
{
unsigned char timeouts = 0;
int received = 0;
socklen_t len;
unsigned char* buff;
if((buff = malloc(MAX_LINE)) == NULL) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
return -1;
}
unsigned char i;
memset(buff, 0, MAX_LINE);
if(encode(buff, PARAM) < 0) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
free(buff);
return -1;
}
if(sendto(*socketpt, buff, 1, 0, remaddr, sizeof(struct sockaddr)) < 0) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
free(buff);
return -1;
}
while(received == 0) {
len = sizeof(struct sockaddr);
if((received = recvfrom(*socketpt, buff, MAX_LINE, 0, remaddr, &len)) < 0) {
if(errno == EWOULDBLOCK) {
if(timeouts == TIMEOUT_NUM) {
fprintf(stderr, "Server non found, process %d, errno %d\n", getpid(), errno);
free(buff);
return -1;
}
received = 0;
timeouts++;
}
else {
fprintf(stderr, "Error occurred, process %d\n errno: %d\n", getpid(), errno);
free(buff);
return -1;
}
}
}
}
memcpy(parameters, uncap(buff), sizeof(unsigned int)*3);
/*"uncap" removes user-level protocol header from payload*/
free(buff);
/*Store old socket port + IP address*/
struct sockaddr_in addr;
len = sizeof(struct sockaddr);
if(getsockname(*socketpt, (struct sockaddr*)&addr, &len) < 0) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
return -1;
}
if(close(*socketpt) < 0) {
fprintf(stderr,"Errore occurred, process %d, errno %d\n", getpid(), errno);
return -1;
}
/*Opens new socket*/
if(((*socketpt) = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
return -1;
}
/*Set timer*/
struct timeval t;
t.tv_usec = parameters[2]; //Where timer is set
if(setsockopt(*socketpt, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0 ) {
fprintf(stderr, "errno: %d\n win: %u\t loss: %u\t timeout: %u\n\n", errno, parameters[0], parameters[1], parameters[2]);
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
if(close(*socketpt) < 0) {
fprintf(stderr, "Errore in close() in clientrequest(), processo %d, errno %d\n", getpid(), errno);
}
return(-1);
}
if(bind(*socketpt, (struct sockaddr*)&addr, sizeof(struct sockaddr)) < 0) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
if(close(*socketpt) < 0) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
}
return(-1);
}
return 0;
}
While once I enter a second request function, it fails at the first sendto() with errno 88.
Here's some sandbox code I tried. It basically follows the same socket(), setsockopt(), bind(), sendto(), close() approach, except "sendto" sends to the same IP/port the socket's bound.
int* receptionfd = malloc(4);
struct sockaddr_in addr;
char buff[MAX_LINE];
int n;
unsigned int len;
if((*receptionfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("Error occurred\n");
free(receptionfd);
exit(-1);
}
memset((void*)&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
if(inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) <= 0) {
perror("Errore occurred\n");
free(receptionfd);
exit(-1);
}
addr.sin_port = htons(5050);
struct timeval t;
t.tv_usec = 20000;
if(setsockopt(*receptionfd, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0 ) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
if(close(*receptionfd) < 0) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
}
return(-1);
}
if(bind(*receptionfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
perror("Error occurred\n");
free(receptionfd);
exit(-1);
}
if(sendto(*receptionfd, buff, 0, 0, (struct sockaddr*)&addr, sizeof(struct sockaddr)) < 0) {
fprintf(stderr, "Error occurred, first sendto(), errno %d\n", errno);
free(receptionfd);
exit(-1);
}
else
printf("First good\n");
close(*receptionfd);
createsock(receptionfd, addr);
if(sendto(*receptionfd, buff, 0, 0, (struct sockaddr*)&addr, sizeof(struct sockaddr)) < 0) {
fprintf(stderr, "Error occurred, second sendto(), errno %d\n", errno);
free(receptionfd);
exit(-1);
}
else {
printf("Second good\n");
}
close(*receptionfd);
free(receptionfd);
exit(0);
createsock() body:
void createsock(int* receptionfd, struct sockaddr_in addr) {
if(((*receptionfd) = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("Error occurred\n");
free(receptionfd);
exit(-1);
}
memset((void*)&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
if(inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) <= 0) {
perror("Error occurred\n");
free(receptionfd);
exit(-1);
}
addr.sin_port = htons(5050);
struct timeval t;
t.tv_usec = 20000;
if(setsockopt(*receptionfd, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0 ) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
if(close(*receptionfd) < 0) {
fprintf(stderr, "Error occurred, process %d, errno %d\n", getpid(), errno);
}
}
if(bind(*receptionfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
perror("Error occurred\n");
exit(-1);
}
}
(You might notice I copy-pasted a few things from the main sandbox function)
Well, the sandbox always executes "First good, Second good".
I might employ a solution using "select()" and see if it works, but I'd rather understand why this is happening first.