Right, hello everyone again....I'm making some progress now...
With the 'Pushes' still left in the server, the output returned to the client is aload of gibberish....
Is there anything that anyone can see that is completely wrong with my code? I'll include my stack, server and client:
STACK :
Code:
#include<stdio.h>
#include"stack.h"
struct store{
int data_int;
char data_char;
int num;
} peeking;
stack_t* stack;
int stack_size;
void push(int d_int, char d_char, stack_t **stackptr) //Pushes integer onto the stack
{
stack_t* push_element; //Stack pointer
push_element = (stack_t*) malloc(sizeof(stack_t)); //Allocating memory
push_element->data_int = d_int;
push_element->data_char = d_char; //Data assigned
push_element->next = (*stackptr); //Next is now equal to the address [which is of type pointer ] that stackptr [pointer to a pointer] points to.
(*stackptr) = push_element; //Address stackptr points to now stores new_element
stack_size++; //Increment stack size, as integer has been pushed
}
void pop(stack_t **stackptr) //Pop integer off the stack
{
int d_int;
char d_char; //Used to store data
stack_t* pop_element; //Stack pointer
if (stack_size != 0) //If stack is not empty
{
pop_element = (*stackptr); //pop_element is now equal to the address [which is of type pointer ] that stackptr [pointer to a pointer] points to.
d_int = pop_element->data_int;
d_char = pop_element->data_char;
//Data is copied
(*stackptr) = pop_element->next; //Stackptr now points to pop_element->next.
free(pop_element); //Remove pointer after usage.
stack_size--; //Decrement stack size, as integer has been popped.
}
}
struct store peek(stack_t **stackptr, int size) //Displays all values in the stack
{
stack_t* peek_element; //Stack pointer
stack_t* store_element; //Stack pointer
int i;
int d_int;
char d_char;
store_element = (*stackptr); //Stack pointer stores address that *stackptr points to.
printf("Peeking at stack:: ");
for ( i=0; i < size; i++) //Loop untill i = stack size.
{
peek_element = (*stackptr); //Peek_element is now equal to the address [which is of type pointer ] that stackptr [pointer to a pointer] points to.
peeking.data_int = peek_element->data_int;
peeking.data_char = peek_element->data_char; //Data is copied
(*stackptr) = peek_element->next; //Stackptr now points to peek_element->next
//Prints value of data
}
return peeking; //Returns value at top of stack
printf("\n"); //New line
(*stackptr) = store_element; //*stackptr now points to store_element, restoring it's orginal value.
}
SERVER:
Code:
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#include"stack.h"
struct receive_data {
char command;
int int_part;
int id_part;
} recv_data;
struct send_data {
char char_data[128];
int int_data;
} s_data;
struct user {
int id;
int total;
int transaction;
stack_t *stack;
}my_user[3];
struct store{
int data_int;
char data_char;
int num;
};
int withdraw(int num, int withdrawl_cash);
int deposit(int num, int deposit_cash);
int main(int argc,char** argv)
{
int i;
int k = 0;
int connfd = 0;
int listenfd = 0;
size_t clilen; //this had not been initialized.
char send_char[128];
char trans[22] = "Transaction Completed";
listenfd = socket(AF_INET, SOCK_STREAM,0); //Creating New Socket
struct sockaddr_in servaddr; //Creating buffer
bzero(&servaddr,sizeof(servaddr)); //Sets all values in buffer to zero
servaddr.sin_family = AF_INET; //Sets the domain
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); //Accepting connections from any machine
servaddr.sin_port = htons(atoi(argv[1])); //First argument, e.g Server 50,000 uses port 50,000
bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)); //Binds a socket to an address
listen(listenfd,10); //Accepts 10 clients to connect
struct sockaddr_in cliaddr, clilen_in;
clilen = sizeof(clilen_in); //This was the most important bit, this is the bit that you discovered
printf("*Server Connected*\n");
//Initializing data for testing purposes (assuming that server will constantly be running, this data would be readily avaliable to the customers)
my_user[0].id = 0000;
my_user[0].total = 10;
my_user[1].id = 1111;
my_user[1].total = 20;
my_user[2].id = 2222;
my_user[2].total = 30;
my_user[3].id = 3333;
my_user[3].total = 40;
my_user[4].id = 4444;
my_user[4].total = 0;
//infinite for loop HERE
//used to accept connections from client
for(;;)
{
connfd = accept(listenfd,(struct sockaddr*)&cliaddr,&clilen); //-1 if nothing is being received
if (connfd != -1)
{
recv(connfd, &recv_data, sizeof(recv_data), 0);
printf("\n\nInstruction Received :: %c ::\n", recv_data.command);
printf("Value Received :: %d ::\n", recv_data.int_part);
fflush(stdout);
if(recv_data.command == 'W')
{
for (i = 0; i < 4; i++)
{
if (my_user[i].id == recv_data.id_part)
{
k = i;
printf("\nUser Number %d", k);
my_user[k].transaction++;
push(recv_data.int_part,recv_data.command,&my_user[k].stack);
}
}
s_data.int_data = withdraw(k,recv_data.int_part);
strcpy(s_data.char_data,trans);
send(connfd, &s_data, sizeof(s_data),0);
}
else if (recv_data.command == 'D')
{
for (i = 0; i < 4; i++)
{
if (my_user[i].id == recv_data.id_part)
{
k = i;
printf("\nUser Number %d", k);
my_user[k].transaction++;
push(recv_data.int_part,recv_data.command,&my_user[k].stack);
}
}
s_data.int_data = deposit(k,recv_data.int_part);;
strcpy(s_data.char_data,trans);
send(connfd, &s_data, sizeof(s_data),0);
}
else if (recv_data.command == 'C')
{
for (i = 0; i < 4; i++)
{
if (my_user[i].id == recv_data.id_part)
{
k = i;
printf("\nUser Number %d", k);
my_user[k].transaction++;
push(recv_data.int_part,recv_data.command,&my_user[k].stack);
}
}
s_data.int_data = my_user[k].total;
strcpy(s_data.char_data,trans);
send(connfd, &s_data, sizeof(s_data),0);
}
else if(recv_data.command == 'M')
{
for (i = 0; i < 4; i++)
{
if (my_user[i].id == recv_data.id_part)
{
k = i;
printf("\nUser Number %d", k);
my_user[k].transaction++;
push(recv_data.int_part,recv_data.command,&my_user[k].stack);
}
}
struct store test[my_user[k].transaction];
for (i=my_user[k].transaction; i > 0 ; i--)
{
test[i] = peek(&my_user[k].stack, i);
}
send(connfd, &test, sizeof(test),0);
}
}
}
}
int withdraw(int num, int withdrawl_cash)
{
printf("\nBefore Withdrawl - %d",my_user[num].total);
my_user[num].total = (my_user[num].total - withdrawl_cash);
printf("\nAfter Withdrawl - %d",my_user[num].total);
return my_user[num].total;
}
int deposit(int num, int deposit_cash)
{
printf("\nBefore Deposit - %d",my_user[num].total);
my_user[num].total = (my_user[num].total + deposit_cash);
printf("\nAfter Deposit - %d",my_user[num].total);
return my_user[num].total;
}
CLIENT:
Code:
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
struct send_data {
char command;
int int_part;
int id_part;
} my_data;
struct store{
int data_int;
char data_char;
int num;
}recv_mini[100];
int sd;
int main(int argc,char** argv)
{
sd = socket(AF_INET, SOCK_STREAM,0);
struct sockaddr_in servaddr;
char recv_data[128];
int recv_data_int;
int e,p,i;
char a;
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET; //Set the domain
servaddr.sin_port = htons(atoi(argv[2])); //The port to connect to
inet_aton(argv[1],&servaddr.sin_addr); //THe IP address of the server machine.
connect(sd,(struct sockaddr*)&servaddr,sizeof(servaddr));
printf("\n*Client Connected*\n");
fflush(stdout);
printf("\nPlease enter your pin number\n");
scanf("%d", &p);
my_data.id_part = p;
printf("\nWhich action would you like?\n\n Withdraw(W)\n Deposit(D)\n Check Balance(C)\n Mini Statement(M)\n Quit(Q)\n\n: ");
scanf("%s", &a);
my_data.command = a;
switch(a)
{
case 'W' : printf("\nHow much would you like to withdraw?\n\n::10:: ::20::\n::30:: ::40::\n::50:: ::100::\n::150:: ::200::\n:");
scanf("%d", &e);
my_data.int_part = e;
send(sd, &my_data, sizeof(my_data), 0);
recv(sd, &recv_data, sizeof(recv_data), 0);
printf("%s\n", recv_data);
fflush(stdout);
break;
case 'D' : printf("\nHow much would you like to deposit?\\n\n::10:: ::20::\n::30:: ::40::\n::50:: ::100::\n::150:: ::200::\n:");
scanf("%d", &e);
my_data.int_part = e;
send(sd, &my_data, sizeof(my_data), 0);
recv(sd, &recv_data, sizeof(recv_data), 0);
printf("%s\n", recv_data);
break;
case 'C' : printf("\nChecking balance...");
send(sd, &my_data, sizeof(my_data), 0);
recv(sd, &recv_data_int, sizeof(recv_data_int), 0);
printf("\nYour balance is ");
printf("%d Pounds\n", recv_data_int);
break;
case 'M' : printf("\nReceiving mini statement...");
send(sd, &my_data,sizeof(my_data),0);
recv(sd, &recv_mini,sizeof(&recv_mini) , 0);
//struct store recv_mini[sizeof(&recv_mini)];
for (i=0; i < sizeof(&recv_mini); i++)
{
printf("%c", recv_mini[i].data_char);
printf("%d", recv_mini[i].data_int);
}
break;
case 'Q' :printf("\nQuitting...\n");
break;
default : printf("\nERROR you have not entered a valid letter, please start over");
break;
}
return 0;
}
Sorry about all the code! Also thanks very much for all of your help thus far.