segmentation fault sockets in c - c

Question

This program is giving a segmentation fault. Can anyone explain why? I tried using gdb. It says, the error is on readFile(). Am i doing something wrong with memcpy? I am trying to transfer a file in bytes from client to server.
Client.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#define BUFFERSIZE 1000
#define IPSIZE 20
#define FILESIZE 100
void readFile(char *name, int sock_fd)
{
FILE *fp = fopen(name, "rb");
char *read_buffer, *buffer[BUFFERSIZE];
unsigned long file_len;
int total_size = 0, flag, rem_size;
//Open file
if (!fp)
{
fprintf(stderr, "Unable to open fp %s", name);
return;
}
//Get file length
fseek(fp, 0, SEEK_END);
file_len=ftell(fp);
fseek(fp, 0, SEEK_SET);
//Allocate memory
read_buffer = (char *)malloc(BUFFERSIZE - 23);
if (!buffer)
{
fprintf(stderr, "Memory error!");
fclose(fp);
return;
}
//Read file contents into buffer
total_size = sizeof(name) + file_len;
printf("Total Size: %d",total_size);
if(file_len < 976)
{
fread(read_buffer, sizeof(read_buffer), 1, fp);
memcpy(buffer, &total_size, sizeof(total_size));
memcpy(buffer[sizeof(total_size)], &name, sizeof(name));
memcpy(buffer[sizeof(total_size)+sizeof(name)], read_buffer, sizeof(read_buffer));
flag = write(sock_fd, htonl(buffer), strlen(buffer));
if (flag < 0)
error("ERROR writing to socket");
}
else
{
while(1)
{
fread(read_buffer, sizeof(read_buffer), 1, fp);
memcpy(buffer, &total_size, sizeof(total_size));
memcpy(buffer[sizeof(total_size)], &name, sizeof(name));
memcpy(buffer[sizeof(total_size)+sizeof(name)], read_buffer, sizeof(read_buffer));
flag = write(sock_fd, htonl(buffer), strlen(buffer));
if (flag < 0)
error("ERROR writing to socket");
rem_size = total_size - 1000;
if(rem_size<0)
break;
}
}
fclose(fp);
}
int main(int argc, char **argv)
{
struct sockaddr_in server_addr;
int sockfd, remote_port_no, n;
char remote_ip[IPSIZE], file_name[FILESIZE];
if(argc!=4)
{
fprintf(stderr,"Usage: ftpc <remote-IP> <remote-port> <local-file-to-transfer>");
exit(0);
}
memset(&(remote_ip), '\0', sizeof(remote_ip)+1);
memcpy(remote_ip, argv[1],sizeof(argv[1])+1);
remote_port_no = atoi(argv[2]);
memset(&(file_name), '\0', sizeof(file_name)+1);
memcpy(file_name, argv[3], sizeof(argv[3])+1);
puts(remote_ip);
puts(file_name);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
printf("OK");
if(sockfd<0)
printf("Socket creation ERROR");
else
printf("Socket creation success");
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(remote_port_no);
server_addr.sin_addr.s_addr = inet_addr(remote_ip);
memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
if(connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
printf("Connect ERROR");
else
printf("Connect Success");
readFile(file_name, sockfd);
return 0;
}
Server.c
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#define BUFFERSIZE 1000
#define IPSIZE 20
#define FILESIZE 100
int main(int argc, char **argv)
{
int listen_fd, connect_fd, n, local_port_no, cli_len;
char buffer[BUFFERSIZE];
struct sockaddr_in serv_addr, client_addr;
FILE *fp;
if(argc != 2)
{
fprintf(stderr,"Usage: ftps <local-port>");
exit(0);
}
local_port_no = atoi(argv[1]);
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(local_port_no);
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
bzero(&(serv_addr.sin_zero), sizeof(serv_addr.sin_zero));
bind(listen_fd, (struct sockaddr *) &serv_addr, sizeof(serv_addr));
listen(listen_fd, 1);
cli_len = sizeof(client_addr);
connect_fd = accept(listen_fd, (struct sockaddr *) &client_addr, &cli_len);
recv(connect_fd, buffer, sizeof(buffer), 0);
fp = open("temp","wb");
printf("%d",sizeof(buffer));
fwrite(buffer, sizeof(buffer[0]), sizeof(buffer)/sizeof(buffer[0]), fp);
close(connect_fd);
}
UPDATE
(gdb) list
55 memcpy(buffer[sizeof(total_size)], &name, sizeof(name));
(gdb) list
50 if(file_len < 976)
51 {
52
53 fread(read_buffer, sizeof(read_buffer), 1, fp);
54 memcpy(buffer, &total_size, sizeof(total_size));
55 memcpy(buffer[sizeof(total_size)], &name, sizeof(name));
56 memcpy(buffer[sizeof(total_size)+sizeof(name)], read_buffer, sizeof(read_buffer));
57 flag = write(sock_fd, htonl(buffer), strlen(buffer));
58 if (flag < 0)
59 error("ERROR writing to socket");

Answer 1

buffer is an array of pointers. Is that what you intended?
Guess not
Therefore it will overrun

Answer 2

A number of obvious problems:
you use sizeof(read_buffer) where read_buffer is a pointer to a malloc'd buffer. This will give you the size of the pointer, not the size of the buffer.
you use strlen(buffer) when buffer contains a bunch of binary data, not a NULL terminated string. This won't work.