int
Readable_timeo(int fd, int sec)
{
int n;
if ( (n = readable_timeo(fd, sec)) < 0)
err_sys("readable_timeo error");
return(n);
}
void do_cli(FILE *fp,int sockfd,const struct sockaddr* servaddr,socklen_t servlen){
int n;
struct datagram sendline,recvline;
int seq=-1;
int resend;
int iseof=0;
char name[4096];
if(fgets(sendline.payload,4096,fp)!=NULL){
strcpy(name,sendline.payload);
sendline.plsize=strlen(sendline.payload);
name[sendline.plsize-1]='\0';
FILE *fi;
fi=fopen(name,"r");
while(1){
seq=(seq+1)%2;
sendline.seq=seq;
if(iseof){
bzero(&sendline.type,sizeof(sendline.type));
sscanf("FIN","%s",&sendline.type);
}
do{
sendto(sockfd,&sendline,sizeof(struct datagram),0,servaddr,servlen);
resend=0;
if(readable_timeo(sockfd,1)==0){
resend=1;
}
else{
n=recvfrom(sockfd,&recvline,sizeof(struct datagram),0,NULL,NULL);
}
}while(resend);
if(iseof){
break;
}
if(feof(fi)){
iseof=1;
continue;
}
bzero(&recvline.seq,sizeof(recvline.seq));
bzero(&recvline.type,sizeof(recvline.type));
bzero(&recvline.payload,sizeof(recvline.payload));
bzero(&recvline.plsize,sizeof(recvline.plsize));
bzero(&sendline.seq,sizeof(sendline.seq));
bzero(&sendline.type,sizeof(sendline.type));
bzero(&sendline.payload,sizeof(sendline.payload));
bzero(&sendline.plsize,sizeof(sendline.plsize));
sendline.plsize=fread(sendline.payload,1,sizeof(sendline.payload),fi);
}
fclose(fi);
}
return;
}
void dg_cli(FILE *fp,int sockfd,const struct sockaddr *sa,socklent_t servlen){
int n;
char sendline[MAXLINE],recvline[MAXLINE+1];
int sec=5;
while(Fgets(sendline,MAXLINE,fp) != NULL){
Sendto(sockfd,sendline,strlen(sendline),0,sa,servlen);
if(readable_timeo(sockfd,5) == 0)
fprintf(stderr,"socket timeout!\n");
else{
n=recvfrom(sockfd,recvline,MAXLINE,0,NULL,NULL);
recvline[n]='\0';
Fputs(recvline,stdout);
}
}
}
void dg_cli(int sockfd,const struct sockaddr* pservaddr,socklen_t servlen)
{
FILE *Output;
Output = fopen("Output2","wb");
if(Output == NULL){
printf("File Open Fail!\n");
return;
}
int nread,nrecv;
char sendbuffer[MAXLINE+1],recvbuffer[MAXLINE+1];
int i;
nread = 0;
int j;
int seq[MAXROW];
char ** back_up = (char**)malloc(sizeof(char*)*MAXROW);
for(i = 0; i < MAXROW; i++){back_up[i] = (char*)malloc(sizeof(char)*MAXLINE+1); }
for(i = 0; i < MAXROW; i++)seq[i] =0;
sprintf(sendbuffer,"%s","Please send!");
int ttt = sendto(sockfd,sendbuffer,strlen(sendbuffer)+1,0,
pservaddr,servlen);
i = 1;
while(1){
if(readable_timeo(sockfd,2) == 0){
fprintf(stderr,"socket timeout\n");
if(seq[i-1] == 0||seq[i] == 0){
if(seq[i-1]==0)sprintf(sendbuffer,"%d",i-1);
else{sprintf(sendbuffer,"%d",i);}
sendto(sockfd,sendbuffer,strlen(sendbuffer),0,pservaddr,servlen);
printf("num:(%s)packet please send again!\n",sendbuffer); }
// continue;
}
else{
nrecv = recvfrom(sockfd,recvbuffer,MAXLINE+1,0,NULL,NULL);
// printf("%d\n",recv);
if(nrecv < 0){
if(seq[i-1] == 0||seq[i] == 0){
if(seq[i-1]==0)sprintf(sendbuffer,"%d",i-1);
else{sprintf(sendbuffer,"%d",i);}
sendto(sockfd,sendbuffer,strlen(sendbuffer),0,pservaddr,servlen);
printf("num:(%s)packet please send again!\n",sendbuffer); }
printf("recvfrom error!\n");
break;
}
else if(nrecv == 0){
memset(sendbuffer,0,sizeof(sendbuffer));
sendto(sockfd,sendbuffer,strlen(sendbuffer),0,pservaddr,servlen);
int max_seq;
for(j = 0; j <= MAXROW; j++){
if(seq[j])max_seq = j;
else if(seq[j] == 0 && seq[j+1]==1)max_seq = j+1;
else break;
}
for(i = 0; i <= max_seq; i++){
printf("%s\n",back_up[i]);
fwrite(back_up[i],sizeof(char),strlen(back_up[i]),Output);
fflush(Output);
}
printf("\n\nfinish! normal close.\n\n");
break;}
else if(nrecv > 0){
// printf("%d ",nrecv);
if(seq[atoi(recvbuffer)] == 1)continue;
seq[atoi(recvbuffer)] = 1;
if(strlen(recvbuffer) == 0)continue;
char seq_num[10];
sprintf(seq_num,"%d",atoi(recvbuffer));
memcpy(back_up[atoi(recvbuffer)],recvbuffer+strlen(seq_num),sizeof(char)*nrecv-strlen(seq_num));
back_up[atoi(recvbuffer)][strlen(back_up[atoi(recvbuffer)])] = 0;
memset(sendbuffer,0,sizeof(sendbuffer));
sprintf(sendbuffer,"%d\n",i);
printf("Please send : %s\n",sendbuffer);
i++;
sendto(sockfd,sendbuffer,strlen(sendbuffer),0,pservaddr,servlen);
// printf("%s\n",sendbuffer);
memset(recvbuffer,0,sizeof(recvbuffer));
memset(sendbuffer,0,sizeof(sendbuffer));
}
}
}
fclose(Output);
return;
}
int main(int argc, char **argv)
{
struct sockaddr_in servaddr;
struct hostent *host;
int udpfd;
int i;
int n;
int connect_success;
int send_len;
int recv_len;
int sequence_number;
int ack_number;
char recv_buf[MTU];
char send_buf[MTU];
char temp_buf[MAX_DATA];
if(argc != 4)
{
printf("Usage: client <IP addr> <port> <input_file>\n");
return 0;
}
memset(&servaddr, 0, sizeof(servaddr));
//get the host information by the name(ip address)
host = gethostbyname(argv[1]);
if(host == NULL)
{
printf("ERROR: Get host by name error\n");
return 0;
}
servaddr.sin_family = PF_INET;
servaddr.sin_port = htons(atoi(argv[2]));
memcpy(&servaddr.sin_addr, host->h_addr, host->h_length);
if((udpfd = socket(PF_INET, SOCK_DGRAM, 0)) <0)
{
printf("ERROR: Create socket error\n");
return 0;
}
FILE* fp=fopen(argv[3],"rb");
if(!fp)
{
printf("ERROR: input file error\n");
return 1;
}
//connect to the server specified in the servaddr
if(connect(udpfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) <0)
{
printf("ERROR: Connect to the server error\n");
fflush(stdout);
return 0;
}
//set_alarm();
connect_success=0;
memset(send_buf,0,sizeof(send_buf));
send_len=sprintf(send_buf,"SYN");
for(i=0;i<RETRY;i++)
{
write(udpfd,send_buf,send_len);
//alarm(ALARM_TIME);
memset(recv_buf,0,sizeof(recv_buf));
if(readable_timeo(udpfd,ALARM_TIME)==0)
{
continue;
/*
if(errno=EINTR)
{
continue;
}
*/
}
else
{
n=read(udpfd,recv_buf,MTU);
//alarm(0);
recv_buf[n]=0;
if(strncmp(recv_buf,"ACK_OF_SYN",10)==0)
{
connect_success=1;
break;
}
}
}
if(connect_success==0)
{
printf("ERROR: Connect to the server error\n");
fflush(stdout);
return 0;
}
sequence_number=0;
for(;;)
{
n=fread(temp_buf,1,MAX_DATA,fp);
if(n==0)
{
//reach EOF
break;
}
memset(send_buf,0,sizeof(send_buf));
send_len=sprintf(send_buf,"%d %d ",sequence_number,n);
memcpy(send_buf+send_len,temp_buf,n);
send_len+=n;
for(;;)
{
write(udpfd,send_buf,send_len);
//alarm(ALARM_TIME);
memset(recv_buf,0,sizeof(recv_buf));
if(readable_timeo(udpfd,ALARM_TIME)==0)
{
continue;
/*
if(errno=EINTR)
{
continue;
}
*/
}
else
{
n=read(udpfd,recv_buf,MTU);
//alarm(0);
recv_buf[n]=0;
if(strncmp(recv_buf,"ACK_OF_DATA ",12)==0)
{
sscanf(recv_buf+12,"%d",&ack_number);
if(ack_number==sequence_number)
break;
}
}
}
sequence_number++;
}
//send FIN
memset(send_buf,0,sizeof(send_buf));
send_len=sprintf(send_buf,"FIN");
int error_time=0;
for(;;)
{
if(error_time>RETRY)
break;
write(udpfd,send_buf,send_len);
//alarm(ALARM_TIME);
memset(recv_buf,0,sizeof(recv_buf));
if(readable_timeo(udpfd,ALARM_TIME)==0)
{
error_time++;
continue;
/*
if(errno=EINTR)
{
continue;
}
*/
}
else
{
n=read(udpfd,recv_buf,MTU);
//alarm(0);
recv_buf[n]=0;
if(strncmp(recv_buf,"ACK_OF_FIN",10)==0)
break;
}
}
fclose(fp);
printf("File Transfer complete\n");
return 0;
}
/***************************************************************************
Function: push_to_cloud
Description:
Input: mt
action_str
old_str
new_str
Output: none
Return: 0:receive status[1(if modifypassword) or 2(if modifyalias)]
positive:receive status[(-9,-10)(if modifypassword) or (-11,-12,-13)(if modifyalias)]
negative:other error
Others: none
***************************************************************************/
static int push_to_cloud(modifyType mt, const char *action_str, const char *old_str, const char *new_str)
{
cJSON *send_json, *receive_json, *status_json;
char *json_send_out;
char send_str[CA_PUSH_TO_CLOUD_LEN], receive_str[CA_PUSH_TO_CLOUD_LEN];
int fd, nwrite, nread, re, nfd;
struct sockaddr_in servaddr;
// Section1: prepare for push
send_json = cJSON_CreateObject();
if (!send_json) {
CA_DEBUG("create send_json failed\n");
return -1;
}
cJSON_AddStringToObject(send_json, "action", action_str);
switch (mt) {
case modifyPasswordType:
cJSON_AddStringToObject(send_json, "old_password", old_str);
cJSON_AddStringToObject(send_json, "new_password", new_str);
break;
case modifyAliasType:
cJSON_AddStringToObject(send_json, "old_alias", old_str);
cJSON_AddStringToObject(send_json, "new_alias", new_str);
break;
default:
CA_DEBUG("undefined modifyType:%d\n", mt);
cJSON_Delete(send_json);
return -1;
}
if ( (json_send_out = cJSON_PrintUnformatted(send_json)) == 0 ) {
CA_DEBUG("%d print send_json failed\n", mt);
cJSON_Delete(send_json);
return -1;
}
cJSON_Delete(send_json);
nwrite = snprintf(send_str, CA_PUSH_TO_CLOUD_LEN, "%s", json_send_out);
nwrite += 1; // including the terminated null
free(json_send_out);
// Section2: send and receive
// reWrite the next line
//fd = Tcp_connect("192.168.1.121", FEATURE_GDGL_CPROXY_CA_PUSH_PORT_STR);
if ( (fd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
CA_DEBUG("%d socket error\n", mt);
return -2;
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(FEATURE_GDGL_CPROXY_CA_PUSH_PORT);
//if ( (re = inet_pton(AF_INET, "192.168.1.238", &servaddr.sin_addr)) <= 0) {
if ( (re = inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr)) <= 0) {
CA_DEBUG("%d inet_pton error:%d\n", mt, re);
close(fd);
return -2;
}
if ( connect(fd, (SA *) &servaddr, sizeof(servaddr)) < 0 ) {
CA_DEBUG("%d connect error\n", mt);
close(fd);
return -2;
}
if ( writen(fd, send_str, nwrite) != nwrite ) {
CA_DEBUG("%d write error\n", mt);
close(fd);
return -2;
}
if ( (nfd = readable_timeo(fd, PUSH_TO_CLOUD_TIMEOUT)) < 0) {
CA_DEBUG("%d readable_timeo error\n", mt);
close(fd);
return -2;
}
else if (nfd == 0) { //timeout, close connection
CA_DEBUG("%d readable_timeo timeout\n", mt);
close(fd);
return -2;
}
while (1) {
if ( (nread = read(fd, receive_str, CA_PUSH_TO_CLOUD_LEN - 1)) < 0) {
if (errno == EINTR)
continue;
else {
CA_DEBUG("%d read error\n", mt);
close(fd);
return -2;
}
}
else if (nread == 0) {
CA_DEBUG("%d closed by other end\n", mt);
close(fd);
return -2;
}
else
break;
}
close(fd);
receive_str[nread] = 0; // add the terminated null
CA_DEBUG("%d receive:\n%s\n", mt, receive_str);
// Section3: parse result
receive_json = cJSON_Parse(receive_str);
if (!receive_json) {
CA_DEBUG("%d receive_json parse Error before:%s\n", mt, cJSON_GetErrorPtr());
return -3;
}
status_json = cJSON_GetObjectItem(receive_json, "status");
if (!status_json) {
cJSON_Delete(receive_json);
CA_DEBUG("%d receive no status\n", mt);
return -3;
}
if (status_json->type != cJSON_Number) {
CA_DEBUG("%d receive status but not a number\n", mt);
cJSON_Delete(receive_json);
return -3;
}
switch (status_json->valueint) {
case PUSH_TO_CLOUD_RESPONSE_JSON_PARSE_FAILED:
CA_DEBUG("%d receive [json parse failed]\n", mt);
cJSON_Delete(receive_json);
return -3;
case PUSH_TO_CLOUD_RESPONSE_REQ_HANDLER_INVALID:
CA_DEBUG("%d receive [request handler invalid]\n", mt);
cJSON_Delete(receive_json);
return -3;
case PUSH_TO_CLOUD_RESPONSE_INVALID_ACTION:
CA_DEBUG("%d receive [invalid action]\n", mt);
cJSON_Delete(receive_json);
return -3;
case PUSH_TO_CLOUD_RESPONSE_UNKNOWN_ACTION:
CA_DEBUG("%d receive [unknown action]\n", mt);
cJSON_Delete(receive_json);
return -3;
default:
break;
}
if (mt == modifyPasswordType) {
switch (status_json->valueint) {
case PUSH_TO_CLOUD_RESPONSE_PASSWD_SUCCESS:
cJSON_Delete(receive_json);
return 0;
case PUSH_TO_CLOUD_RESPONSE_INVALID_OLD_PASSWD:
CA_DEBUG("%d receive [invalid old_password]\n", mt);
cJSON_Delete(receive_json);
return -3;
case PUSH_TO_CLOUD_RESPONSE_INVALID_NEW_PASSWD:
CA_DEBUG("%d receive [invalid new_password]\n", mt);
cJSON_Delete(receive_json);
return -3;
case PUSH_TO_CLOUD_RESPONSE_OLD_PASSWD_ERR:
CA_DEBUG("%d receive [old password not correct]\n", mt);
cJSON_Delete(receive_json);
return clientAdminPushToCloudOldPasswdErr;
case PUSH_TO_CLOUD_RESPONSE_PASSWD_SAME:
CA_DEBUG("%d receive [same passwords]\n", mt);
cJSON_Delete(receive_json);
return clientAdminPushToCloudPasswdSame;
default:
CA_DEBUG("%d receive unsupported status:[%d]\n", mt, status_json->valueint);
cJSON_Delete(receive_json);
return -3;
}
}
else if (mt == modifyAliasType) {
switch (status_json->valueint) {
case PUSH_TO_CLOUD_RESPONSE_ALIAS_SUCCESS:
cJSON_Delete(receive_json);
return 0;
case PUSH_TO_CLOUD_RESPONSE_INVALID_OLD_ALIAS:
CA_DEBUG("%d receive [invalid old_alias]\n", mt);
cJSON_Delete(receive_json);
return -3;
case PUSH_TO_CLOUD_RESPONSE_INVALID_NEW_ALIAS:
CA_DEBUG("%d receive [invalid new_alias]\n", mt);
cJSON_Delete(receive_json);
return -3;
case PUSH_TO_CLOUD_RESPONSE_OLD_ALIAS_NOT_EXIST:
CA_DEBUG("%d receive [old alias not exist]\n", mt);
cJSON_Delete(receive_json);
return clientAdminPushToCloudOldAliasNotExist;
case PUSH_TO_CLOUD_RESPONSE_NEW_ALIAS_EXIST:
CA_DEBUG("%d receive [new alias already exist]\n", mt);
cJSON_Delete(receive_json);
return clientAdminPushToCloudNewAliasExist;
case PUSH_TO_CLOUD_RESPONSE_ALIAS_SAME:
CA_DEBUG("%d receive [same aliases]\n", mt);
cJSON_Delete(receive_json);
return clientAdminPushToCloudAliasSame;
default:
CA_DEBUG("%d receive unsupported status:[%d]\n", mt, status_json->valueint);
cJSON_Delete(receive_json);
return -3;
}
}
else {
CA_DEBUG("undefined modifyType:%d\n", mt);
cJSON_Delete(receive_json);
return -3;
}
}
