title: Sending Image (JPG) through Socket in C using raspberry pi and windows
body: <p>I'm writing a C program in order to be able to transfer  an image file continously between raspberry pi and windows pc computer (from server raspberry pi to client pc) using TCP/IP sockets but there seems to be an error after sending for the  1017th time ,the server quits by stating segmentation fault , i mean in a loop when i intend to send the image file to my client 2000 times the server quits on 1017th image.</p>
  
  <p>server side</p>
  
  <pre><code>#include&lt;stdio.h&gt;
  #include&lt;string.h&gt;
  #include&lt;sys/socket.h&gt;
  #include&lt;arpa/inet.h&gt;   
  #include&lt;unistd.h&gt;  
  #include&lt;iostream&gt;
  #include&lt;fstream&gt;
  #include&lt;errno.h&gt;
  
  using namespace std;
  
  int send_image(int socket){
  
      FILE *picture;
      int size, read_size, stat, packet_index;
      char send_buffer[10240], read_buffer[256];
      packet_index = 1;
  
      picture = fopen("a.jpg", "r");
      printf("Getting Picture Size\n");   
  
      if(picture == NULL) {
          printf("Error Opening Image File"); 
      }
  
      fseek(picture, 0, SEEK_END);
      size = ftell(picture);
      fseek(picture, 0, SEEK_SET);
      printf("Total Picture size: %i\n",size);
  
      //Send Picture Size
      printf("Sending Picture Size\n");
      write(socket, (void *)&amp;size, sizeof(int));
  
      //Send Picture as Byte Array
      printf("Sending Picture as Byte Array\n");
  
      do { //Read while we get errors that are due to signals.
          stat=read(socket, &amp;read_buffer , 255);
          printf("Bytes read: %i\n",stat);
      } while (stat &lt; 0);
  
      printf("Received data in socket\n");
      printf("Socket data: %c\n", read_buffer);
  
      while(!feof(picture)) {
          //while(packet_index = 1){
          //Read from the file into our send buffer
          read_size = fread(send_buffer, 1, sizeof(send_buffer)-1, picture);
  
          //Send data through our socket 
          do{
              stat = write(socket, send_buffer, read_size);  
          }while (stat &lt; 0);
  
          printf("Packet Number: %i\n",packet_index);
          printf("Packet Size Sent: %i\n",read_size);     
          printf(" \n");
          printf(" \n");
  
          packet_index++;  
  
          //Zero out our send buffer
          bzero(send_buffer, sizeof(send_buffer));
      }
  }
  
  int main(int argc , char *argv[])
  {
      int socket_desc , new_socket , c, read_size,buffer = 0;
      struct sockaddr_in server , client;
      char *readin;
  
      //Create socket
      socket_desc = socket(AF_INET , SOCK_STREAM , 0);
      if (socket_desc == -1)
      {
          printf("Could not create socket");
      }
  
      //Prepare the sockaddr_in structure
      server.sin_family = AF_INET;
      server.sin_addr.s_addr = INADDR_ANY;
      server.sin_port = htons( 8000 );
  
      //Bind
      if( bind(socket_desc,(struct sockaddr *)&amp;server , sizeof(server)) &lt; 0)
      {
          puts("bind failed");
          return 1;
      }
  
      puts("bind done");
  
      //Listen
      listen(socket_desc , 3);
  
      //Accept and incoming connection
      puts("Waiting for incoming connections...");
      c = sizeof(struct sockaddr_in);
  
      if((new_socket = accept(socket_desc, (struct sockaddr *)&amp;client,       (socklen_t*)&amp;c))){
          puts("Connection accepted");
       }
  
       fflush(stdout);
  
       if (new_socket&lt;0)
       {
           perror("Accept Failed");
           return 1;
       }
       while(value&lt;2000)
       {
           value =value+1;
           send_image(new_socket);
       }
  
       close(socket_desc);
       fflush(stdout);
       return 0;
  }
  </code></pre>
  
  <p>client side.</p>
  
  <pre><code>#include&lt;stdio.h&gt;
  #include&lt;string.h&gt;
  #include&lt;sys/socket.h&gt;
  #include&lt;arpa/inet.h&gt;   
  #include&lt;sys/ioctl.h&gt;
  #include&lt;unistd.h&gt;  
  #include&lt;iostream&gt;
  #include&lt;fstream&gt;
  #include&lt;errno.h&gt;
  
  using namespace std;
  
  //This function is to be used once we have confirmed that an image is to be  sent
  //It should read and output an image file
  
  int receive_image(int socket)
  { // Start function 
      int imgc = 0 ; 
  
      while(imgc &lt; 2000)
      {
          int buffersize = 0, recv_size = 0,size = 0, read_size, write_size,  packet_index =1,stat;
  
          char imagearray[10240],verify = '1';
          FILE *image;
          int value = 0 ; 
          //Find the size of the image
  
          value = value + 1;  
  
          do{
              stat = read(socket, &amp;size, sizeof(int));
          }while(stat&lt;0);
  
          printf("size = %d" , size) ; 
  
          if(size&gt;1000)
          {
              imgc = imgc + 1 ; 
              char buffer[] = "Got it";
  
             //Send our verification signal
             do{
                 stat = write(socket, &amp;buffer, sizeof(int));
             }while(stat&lt;0);
  
             printf("Reply sent\n");
             printf(" \n");
  
             char fn[100] ; 
  
             sprintf(fn,"a%d.jpg",imgc);
  
             image = fopen(fn, "wb"); 
  
             if( image == NULL) {
                 printf("Error has occurred. Image file could not be opened\n");
                 return -1; 
             }
  
             //Loop while we have not received the entire file yet
  
             int need_exit = 0;
             struct timeval timeout = {10,0};
  
             fd_set fds;
             int buffer_fd, buffer_out;
  
             while(recv_size &lt; size) {
                 //while(packet_index &lt; 2){
                 FD_ZERO(&amp;fds);
                 FD_SET(socket,&amp;fds);
  
                 buffer_fd = select(FD_SETSIZE,&amp;fds,NULL,NULL,&amp;timeout);
                 if (buffer_fd &lt; 0)
                     printf("error: bad file descriptor set.\n");
  
                if (buffer_fd == 0)
                    printf("error: buffer read timeout expired.\n");
  
                if (buffer_fd &gt; 0)
                {
                    do{
                        read_size = read(socket,imagearray, 10240);
                    }while(read_size &lt;0);
  
                    printf("Packet number received: %i\n",packet_index);
                    printf("Packet size: %i\n",read_size);
  
                    //Write the currently read data into our image file
                    write_size = fwrite(imagearray,1,read_size, image);
                    printf("Written image size: %i\n",write_size); 
  
                    if(read_size !=write_size) {
                        printf("error in read write\n");
                    }
  
                    //Increment the total number of bytes read
                    recv_size += read_size;
                    packet_index++;
                    printf("Total received image size: %i\n",recv_size);
                    printf(" \n");
                    printf(" \n");
                }
            }
  
            fclose(image);
            printf("Image successfully Received!\n");
         }
  
     }      
     return 1;
  }
  
  int main(int argc , char *argv[])
  {
      int socket_desc;
      struct sockaddr_in server;
      char *parray;
  
  
      //Create socket
      socket_desc = socket(AF_INET , SOCK_STREAM , 0);
  
      if (socket_desc == -1) {
          printf("Could not create socket");
      }
  
      memset(&amp;server,0,sizeof(server));
      server.sin_addr.s_addr = inet_addr("192.168.137.137");
      server.sin_family = AF_INET;
      server.sin_port = htons( 8000 );
  
      //Connect to remote server
      if (connect(socket_desc , (struct sockaddr *)&amp;server , sizeof(server)) &lt; 0)      {
          cout&lt;&lt;strerror(errno);
          close(socket_desc);
          puts("Connect Error");
          return 1;
      }
  
      puts("Connected\n");
  
      receive_image(socket_desc);
  
      close(socket_desc);
  
      return 0;
  }
  </code></pre>