sprintf / snprintf not correctly writing to buffer - c

Question

I have to write a TCP server program that holds an integer, that should be modifiable by the client programs. It should kind of resemble a bankaccount. Everything works fine, except one thing:
When a client first connects to the server, it will wait for a welcoming message (the server has to be iterative, so it should only handle one client at a time). The server always just sends the first couple of letters of the welcoming message. All other messages are transferred completely and correctly.
In line 49, the welcoming message is first copied to a char-array and then written to the socket. This is where the error is... Only the first 1-5 letters are sent (different each time a new client connects). In other places where I use sprintf() to copy a message to a char-array and then writing it to the socket, everything works just like I want it to.
I have also tried using snprintf(), but that doesn't work either. What am I doing wrong? :D
So this would be an example output on client side:
Connected!
Waiting for welcome message...
We
After that, I could start entering commands to the server. But the whole welcome message is cut of after two letters. But as said above, sometimes its just one letter, sometimes its five :D.
Anyway, here's my code (if there are any other errors or things I should avoid, feel free to tell me :D):
client:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#define BufferSize 99999
void error(const char *msg) {
fprintf(stderr, "%s\n", msg);
exit(EXIT_FAILURE);
}
int main(int argc, char *argv[]) {
int sockfd, portno, n;
struct sockaddr_in serv_addr;
struct hostent *server;
char msg[BufferSize], data[BufferSize];
if (argc < 3) error("usage: <hostname> <port>\n");
server = gethostbyname(argv[1]);
if (server == NULL) error("Host not found!");
portno = atoi(argv[2]);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) error("socket() error");
bzero((char *) &serv_addr, sizeof (serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *) server->h_addr, (char *) &serv_addr.sin_addr.s_addr, server->h_length);
serv_addr.sin_port = htons(portno);
if (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof (serv_addr)) < 0) error("connect() error");
printf("Connected!\nWaiting for welcome message...\n");
memset(msg, 0, BufferSize);
n = read(sockfd, msg, BufferSize - 1);
if (n < 0) error("read() error");
printf("%s\n", msg);
memset(data, 0, BufferSize);
while (fgets(data, BufferSize, stdin) != NULL) {
data[strlen(data) - 1] = '\0'; //remove trailing newline char
n = write(sockfd, data, strlen(data) + 1);
if (n < 0) error("write() error");
if (strcmp(data, "exit") == 0) break;
memset(msg, 0, BufferSize);
n = read(sockfd, msg, BufferSize - 1);
if (n < 0) error("read() error");
if (n==0) error("Server shut down...");
printf("%s\n", msg);
memset(data, 0, BufferSize);
}
close(sockfd);
return 0;
}
server:
#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 <limits.h>
#define BufferSize 99999
#define ClientWaiting 100
void error(const char *msg) {
fprintf(stderr, "%s\n", msg);
exit(EXIT_FAILURE);
}
int main(int argc, char *argv[]) {
int sockfd, newsockfd, portno, n, amount, balance, balOld;
socklen_t clilen;
char msg[BufferSize], data[BufferSize], *splitBuf[2];
struct sockaddr_in serv_addr, cli_addr;
balance = 0;
if (argc < 2) error("usage: <port>");
portno = atoi(argv[1]);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) error("socket() error");
memset(&serv_addr, 0, sizeof (serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);
if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof (serv_addr)) < 0) error("bind() error");
listen(sockfd, ClientWaiting);
while (1) {
printf("Waiting for new client...\n");
clilen = sizeof (cli_addr);
newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0) error("accept() error");
printf("New connection accepted...\n");
memset(data, 0, BufferSize);
sprintf(data, "Welcome!\nPlease use the following commands:\n<put, get> <positive integer>\nBalance: %d€", balance);
n = write(newsockfd, data, strlen(msg) + 1);
if (n < 0) error("write() error");
while (1) {
splitBuf[0] = NULL;
splitBuf[1] = NULL;
memset(data, 0, BufferSize);
memset(msg, 0, BufferSize);
n = read(newsockfd, msg, BufferSize - 1);
if (n < 0) {
fprintf(stderr, "read() error\n");
break;
}
if (n == 0) {
printf("Client disconnected...\n");
break;
}
printf("Message received: %s\n", msg);
if (strcmp(msg, "exit") == 0) break;
splitBuf[0] = strtok(msg, " ");
splitBuf[1] = strtok(NULL, " ");
if (splitBuf[1] == NULL) {
strcpy(data, "Please use the following commands:\n<put, get> <positive integer>");
} else {
amount = atoi(splitBuf[1]);
if (amount <= 0) {
strcpy(data, "Please use the following commands:\n<put, get> <positive integer>");
} else if (strcmp(splitBuf[0], "put") == 0) {
balOld = balance;
balance += amount;
if (balance < balOld) {
balance = INT_MAX;
sprintf(data, "Warning! Overflow!\nBalance: %d€", balance);
} else {
sprintf(data, "Balance: %d€", balance);
}
printf("New balance: %d€\n", balance);
} else if (strcmp(splitBuf[0], "get") == 0) {
balOld = balance;
balance -= amount;
if (balance > balOld) {
balance = INT_MIN;
sprintf(data, "Warning! Underflow!\nBalance: %d€", balance);
} else {
sprintf(data, "Balance: %d€", balance);
}
printf("New balance: %d€\n", balance);
}
}
n = write(newsockfd, data, strlen(data) + 1);
if (n < 0) error("write() error");
}
close(newsockfd);
}
close(newsockfd);
close(sockfd);
return 0;
}

Answer 1

This example is way too long for people on SO to debug. (We're not compilers and debuggers.)
Your first step must be decomposing the program into smaller, more easily understood pieces that can be debugged independently. There are a couple of ways of doing that:
adding checkpoints that test your assertions
breaking code into more easily understandable and independently testable functions
For example, I look at:
splitBuf[0] = strtok(msg, " ");
splitBuf[1] = strtok(NULL, " ");
Does splitBuf contain what you expect? (Is NULL a valid parameter to strtok?)
I recommend two things:
#include
# Are my assumptions met?
assert( splitBuf[0]!=null );
assert( splitBuf[1]!=null );
#ifdef DEBUG
printf("splitBuf[0]=%s\n", splitBuf[0]);
printf("splitBuf[1]=%s\n", splitBuf[1]);
#endif
Compile with -DDEBUG=1 to ensure that DEBUG is defined, or add:
#define DEBUG
at the top of the file.
Second, programming is much easier if you tackle smaller problems, then work on and test your answers to those problems independently. Let's say you need to parse a message from the network and extract a balance, then you might write:
int parseBalance(char const* serverMessage) {
...
return balance;
}
You can now write a test:
void tests()
{
// test parseBalance
assert( 100 == parseBalance("100") )
... more tests
}
Minimally, you could call tests() at the start of your program to perform a self-test (read up on "unit testing" for better approaches).
IF you program in this way:
often the problems will become more easily apparent
if you are stuck and post to SO, you only need to post the minimal function and test case.

Answer 2

I believe your problem is in your first read() call. You do a single read, expecting to get all of the welcome message. But that isn't how TCP works. TCP puts the stream data into packets according to its own internal rules, and the receiving system can make it available in any amount it wants.
You cannot rely on getting all of the data the server wrote in a single read.
In fact the server is messed up too. You cannot expect a write call to write everything you say. The operating system's send buffer for the socket might be full or it might have had a signal interrupt the call.
You need send and receive buffers and functions to handle a loop around read and write that continues until you receive a complete line or send a complete buffer.