transfer binary over socket

I want to transfer a binary file over a socket.

The file has been fread into a character buffer and can be successfully fwritten back out locally. Using write and read on the socket file descriptors seemed to work in the sense that a file of the correct size is transferred, but it's not executable (or viewable, with an image).

If I want to use fread and fwrite, I have to use fdopen on the socket descriptor to get a stream. This works on the transmission end, but

FILE sstrIN=fdopen(fd,"rb");

fails, altho fcntl reports the read flag is set for fd. Am I going about this the wrong way, or are there more details?

Quote:

---

FILE sstrIN=fdopen(fd,"rb");

---

FILE or FILE *?

What is errno after the failure?

gg

Quote:

---

Originally Posted by Codeplug

What is errno after the failure?

---

Bad file descriptor


However, the fd is working fine with "read" and write".

I actually have been unable to repeat the situation where this works on the transmit end -- ie, apparently I cannot create a stream for a socket descriptor AT ALL.

The other strange element is that it would seem to me (based on the reading I've done) that I shouldn't even have to -- simply writing the buffer in a single chunk on the socket should work fine (can anyone confirm this?). As I said, there is a transfer that creates a binary file of the correct size, but the file is non-functional. I wouldn't know where to start in analyzing "what's wrong with it?"

I assume you got fd from either putting in the stdin/out file descriptors, or you obtained it through socket() or open().

I've always just used send() and recv() on sockets.

gg

Ditto. But its not an uncommon practice to use fdopen() with sockets.

Quote:

---

Originally Posted by Codeplug

I've always just used send() and recv() on sockets.

---

Yes, it would seem irrefutable now.

If anyone has time and can see what's wrong, this is the code:

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>

       
short int loclconn (char *socket, int fd) {
        size_t size;
        struct sockaddr_un peer;
        peer.sun_family=AF_LOCAL;
        strcpy(peer.sun_path,socket);
        size=SUN_LEN(&peer);
        return connect(fd,(struct sockaddr*)&peer,size);
}


short int loclsckt (char *file) {
        struct sockaddr_un name;
        short int sock;
        size_t size;

        if ((strlen(file)) > 107) return -2;
        if ((sock=socket(PF_LOCAL,SOCK_STREAM,0)) < 0) return -1;

        name.sun_family = AF_LOCAL;       
        strcpy(name.sun_path, file);       
        size=SUN_LEN(&name);
        if ((bind(sock,(struct sockaddr*)&name,size) < 0)) return -3;
        return sock;
}


int main (int argc, char *argv[]) {
        short int pid, CHLD, PARN, OUT, IN;
        size_t len;
        int bytes;
        char *buffer, *buffer2;
        struct stat finfo;
        FILE *fstRO = fopen(argv[1], "rb"), * sstOUT;
        FILE *fstW = fopen("/root/test/image.jpg", "wb");
        struct sockaddr addr;

        if (fstRO == NULL) {
                puts("valid filename required");
                return -1;}
       
        stat(argv[1],&finfo);
        bytes=finfo.st_size;
        buffer=malloc(bytes);
        buffer2=malloc(bytes);
       
        printf("&#37;d\n",bytes);
       
        fread(buffer,bytes,1,fstRO);
        fclose(fstRO);

        pid=fork();
        if (pid == 0) {
                puts("child");
                CHLD=loclsckt("/root/test/sock1");
                OUT=loclconn("/root/test/sock2",CHLD);
                if ((sstOUT=fdopen(OUT,"wb"))==NULL) perror("fdopen");
                write(OUT,buffer,bytes);
                close(OUT);
                close(CHLD);
                unlink("/root/test/sock1");
                return;
        }
        puts("parent");
        PARN=loclsckt("/root/test/sock2");
        listen(IN,0);
        IN=accept(PARN,&addr,&len);
        read(IN,buffer2,bytes);
        close(IN);
        close(PARN);
        unlink("/root/test/sock2");

        fwrite(buffer2,bytes,1,fstW);
        fclose(fstW);
}

---

As is, it does everything I mentioned -- a normal read/write on the descriptors (producing a defuct file) and an attempt to create a stream on the child (send) descriptor, which fails and gives perror.

Are you supposed to close a descriptor like that after using fdopen()? I am going to have to do a check. But methinks that is the problem.

Quote:

---

The fdopen() function associates a stream with the existing file descriptor, fildes. The mode of the stream (one of the values "r", "r+", "w", "w+", "a", "a+") must be compatible with the mode of the file descriptor. The file position indicator of the new stream is set to that belonging to fildes, and the error and end-of-file indicators are cleared. Modes "w" or "w+" do not cause truncation of the file. The file descriptor is not dup'ed, and will be closed when the stream created by fdopen() is closed. The result of applying fdopen() to a shared memory object is undefined.

---

You can stop pulling hair out of your head now. Just ditch the closing the handle line and you are good.

No, that's not the problem (I took all the closes out and it does the same thing). I don't see how closing descriptors and streams after you're done using them would matter.

The only "unconventional" thing I did was to put the socket code in a function, which means the struct sockaddr stuff would be lost. I haven't tried putting that back into main because I assumed it doesn't matter after the socket is created/connected.

Perhaps it is the "wb"...nope

Why are you using a short int? This shouldn't be the problem, but I am also not going to say it can't be the problem.

I am going to be blunt, why are you even using fdopen to begin with? Your code doesn't really utilize its functionality.

No, don't take out the closes, just take out the fclose you fdopened.

Quote:

---

Originally Posted by master5001

Why are you using a short int? This shouldn't be the problem, but I am also not going to say it can't be the problem.

---

On my computer I am unlikely to recieve file descriptor 33454 (etc). But I tried switching "short int" to "int" -- same thing.

As I mentioned, I didn't think that was the issue, I am just issuing you a warning in more human terms than your compiler issues warnings in. Because you will listen to us where your compiler fails to get through to you. And yeah your closes are all out of whack. And more importantly, your code doesn't look like it uses any of the C stream functionality at all... well except for fclose()........

Quote:

---

Originally Posted by MK27

On my computer I am unlikely to recieve file descriptor 33454 (etc). But I tried switching "short int" to "int" -- same thing.

---

Even if it's UNLIKELY, being correct is important when it comes to computers.

--
Mats

Quote:

---

Originally Posted by robwhit

No, don't take out the closes, just take out the fclose you fdopened.

---

that fclose is on the steam which read the file into a buffer. It's irrelevant to all the socket stuff. The buffer already contains the file, then gets transmitted.

Here is the deal.... fclose() will clean up after the FILE * structure produced by fdopen(). close() will just close the descriptor you have opened. This is where Mats is free to jump in with a correction, but you should only call fclose().

Quote:

---

Originally Posted by master5001

Here is the deal.... fclose() will clean up after the FILE * structure produced by fdopen(). close() will just close the descriptor you have opened. This is where Mats is free to jump in with a correction, but you should only call fclose().

---

Well, for argument's sake I tried it, and it didn't matter. Just to clarify, tho -- you do understand that

fclose(fstRO);

refers to

FILE *fstRO = fopen(argv[1], "rb")

and NOT

if ((sstOUT=fdopen(OUT,"w"))==NULL) perror("fdopen");

And: what file structure created by fdopen? The problem is that fdopen isn't creating anything, it returns NULL on an apparently bad descriptor, but the next command

write(OUT,buffer,bytes);

succeeds (OUT being the "Bad descriptor").

once you fdopen() you should be using fwrite() anyway. But I somehow doubt that is the real problem.

Quote:

---

Originally Posted by master5001

As I mentioned, I didn't think that was the issue, I am just issuing you a warning in more human terms than your compiler issues warnings in. Because you will listen to us where your compiler fails to get through to you. And yeah your closes are all out of whack. And more importantly, your code doesn't look like it uses any of the C stream functionality at all... well except for fclose()........

---

I'm taking this to heart because I obviously want your advice. What do you mean by "your code doesn't look like it uses any of the C stream functionality at all":

Code:

---

        FILE *fstRO = fopen(argv[1], "rb"),  * sstOUT;
        FILE *fstW = fopen("/root/test/image.jpg", "wb");
        struct sockaddr addr;

        if (fstRO == NULL) {
                puts("valid filename required");
                return -1;}
       
        stat(argv[1],&finfo);
        bytes=finfo.st_size;
        buffer=malloc(bytes);
        buffer2=malloc(bytes);
       
        printf("%d\n",bytes);
       
        fread(buffer,bytes,1,fstRO);
        fclose(fstRO);

---

Is all the C stream functionality I could muster, except for the final buffer write and

Code:

---

if ((sstOUT=fdopen(OUT,"w"))==NULL) perror("fdopen");

---

which is just there to demonstrate that it doesn't work.

And what, pray tell, are my closes "out of whack" with?

ps. I didn't use fwrite because -- once again -- fdopen (there is only one) FAILED. The write is to the socket descriptor, not a stream.
pps. I just noticed that cboard will not accept "* sst" without the space, and instead replaced it with ........ perhaps I am haunted today.

Ah ok. Well is fdopen() failed because of an invalid descriptor, then anything done with that descriptor should be equally ineffective, right? So why are you getting an invalid socket to begin with becomes the question. I don't believe you can use bind with AF_LOCAL. I am going to see what I can find. Double check the socket you are making to make sure it is even valid.

Ok yeah I am really starting to think the problem is with how you create your socket to begin with. I am not as familiar with AF_LOCAL to be trouble shooting your code by hand at this point. So I did read some manual pages to see what that address family does support, and it looks like there are a few things that it doesn't necessarily allow. You are probably doing something outside of the scope of that kind of socket.

Quote:

---

Originally Posted by master5001

Double check the socket you are making to make sure it is even valid.

---

AHHHRGGHHH!!!! How many times do I have to point out that the fd is obviously valid because the file transfer DOES happen.

w/r/t bind, I'll check that out -- all the examples I found were INET, but nowhere in the GNU documentation does it say "don't bind local sockets".

[moment later] no, I guess you don't have to bind them, but it still works out the same way

I couldn't find any formal documentation behind binding local sockets. Ok so it is valid (obviously) then perhaps fdopen() simply doesn't support that kind of socket. Ok so lets just remove fdopen() from the picture, does your code work if you comment out those lines of code?

But according to RobSeace, adminstrator of the unix socket forum (a little undercrowded, surprise) on developerweb, "the fdopen() trick SHOULD work fine, if you really wanted to go that route...But, it's really not necessary"

Which I didn't want to, I started out doing it because the file transferred on the descriptor with read/write is/was bum, etc. And again, according to all the sources (eg. Codeplug) that is the usual way to go and it should work.

Maybe it's my kernel;)

I am thinking it is an issue of the type of connection you are creating not being supported by fdopen(). And yes, conventional wisdom suggests that fdopen() should work. However, evidence seems to suggest otherwise (which is a kick in the teeth when these things happen).

Try making a non-local connection and seeing if fdopen() will work. Why not rebuild your kernel to support the support fdopen() with AF_LOCAL.

Quote:

---

Originally Posted by master5001

Why not rebuild your kernel to support the support fdopen() with AF_LOCAL.

---

Probably I should try this first.

Just google your kernel version, OS, and the problem. Usually someone out there will tell you exactly which flags will need to be set for this. Unless you like rooting through your kernel's source code. Which is fine if you do, you are a better man than I if so.

Looking at this in the fresh morning air, I realized what a mess I had made (no thanks to master5001, but much to RobSeace...)

So for posterity, here's my working code for binary transfer on a local unix socket (for which there may be a few uses, who knows?):

Code:

---

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/stat.h>

       
int loclconn (char *socket, int fd) {
        size_t size;
        struct sockaddr_un peer;
        peer.sun_family=AF_LOCAL;
        strcpy(peer.sun_path,socket);
        size=SUN_LEN(&peer);
        return connect(fd,(struct sockaddr*)&peer,size);
}


int loclsckt (char *file) {
        struct sockaddr_un name;
        int sock;
        size_t size;

        if ((strlen(file)) > 107) return -2;
        if ((sock=socket(PF_LOCAL,SOCK_STREAM,0)) < 0) return -1;
       
        name.sun_family = AF_LOCAL;       
        strcpy(name.sun_path, file);
        size=SUN_LEN(&name);
        if ((bind(sock,(struct sockaddr*)&name,size) < 0)) return -3;
        return sock;
}


int main (int argc, char *argv[]) {
        int pid, CHLD, PRNT, IN;
        size_t len;
        int bytes;
        char *buffer, *buffer2;
        struct stat finfo;
        FILE *fstRO = fopen(argv[1], "rb");
        FILE *fstW = fopen("/root/test/image.jpg", "wb");
        struct sockaddr addr;

        if (fstRO == NULL) {
                puts("valid filename required");
                return -1;}
       
        stat(argv[1],&finfo);
        bytes=finfo.st_size;
        buffer=malloc(bytes);
        buffer2=malloc(bytes);
       
        fread(buffer,bytes,1,fstRO);
        fclose(fstRO);
       
        PRNT=loclsckt("/root/test/testsock");
        listen(PRNT,5);
        if ((CHLD=socket(PF_LOCAL,SOCK_STREAM,0)) < 0) perror("socket");

        pid=fork();
        if (pid == 0) {
                if (loclconn("/root/test/testsock",CHLD) < 0) perror("localconn");
                if(write(CHLD,buffer,bytes) == -1) perror("write");
                close(CHLD);
                return;
        }
        IN=accept(PRNT,&addr,&len);
        read(IN,buffer2,bytes);
        close(IN);
        close(PRNT);
        unlink("/root/test/testsock");

        fwrite(buffer2,bytes,1,fstW);
        fclose(fstW);
}

---