Merge pull request #48 from enkiller/0828_1428

armink · web-flow · commit 870a5798014d · 2020-08-28T14:53:03.000+08:00
完善客户端文件传输请求
diff --git a/tftp/tftp.h b/tftp/tftp.h
@@ -32,6 +32,7 @@
 struct tftp_client
 {
     int max_retry;
+    int err;
     void *_private;
 };
 
@@ -47,6 +48,7 @@ struct tftp_client *tftp_client_create(const char *ip_addr, int port);
 void tftp_client_destroy(struct tftp_client *client);
 int tftp_client_push(struct tftp_client *client, const char *local_name, const char *remote_name);
 int tftp_client_pull(struct tftp_client *client, const char *remote_name, const char *local_name);
+int tftp_client_err(struct tftp_client *client);
 struct tftp_server *tftp_server_create(const char *root_name, int port);
 void tftp_server_run(struct tftp_server *server);
 void tftp_server_destroy(struct tftp_server *server);
diff --git a/tftp/tftp_client.c b/tftp/tftp_client.c
@@ -74,6 +74,8 @@ struct tftp_client *tftp_client_create(const char *ip_addr, int port)
     }
     /* Number of Initial Retries */
     client->max_retry = TFTP_MAX_RETRY;
+    /* Initialization error number */
+    client->err = TFTP_OK;
     /* Binding Private Data */
     client->_private = _private;
     return client;
@@ -102,6 +104,7 @@ int tftp_client_push(struct tftp_client *client, const char *local_name, const c
 
     _private = client->_private;
     max_retry = client->max_retry;
+    client->err = TFTP_OK;
     while (max_retry)
     {
         /* Send Write Request */
@@ -110,6 +113,7 @@ int tftp_client_push(struct tftp_client *client, const char *local_name, const c
         {
             tftp_printf("tftp send request failed !! retry:%d. exit\n", client->max_retry - max_retry);
             max_retry = 0;
+            client->err = res;
             break;
         }
         /* Waiting for server response */
@@ -121,15 +125,16 @@ int tftp_client_push(struct tftp_client *client, const char *local_name, const c
         }
         else if (res == -TFTP_ETIMEOUT)
         {
-            tftp_printf("tftp selct timeout. retry\n");
+            tftp_printf("tftp wait response timeout. retry\n");
             max_retry --;
             continue;
         }
         else
         {
             /* Waiting for Response Error */
-            tftp_printf("tftp selct err:%d. exit\n", res);
+            tftp_printf("tftp wait response err:%d. exit\n", res);
             max_retry = 0;
+            client->err = res;
             break;
         }
     }
@@ -143,20 +148,23 @@ int tftp_client_push(struct tftp_client *client, const char *local_name, const c
     if (res != TFTP_OK)
     {
         tftp_printf("wait ack failed!! exit\n");
+        client->err = res;
         return res;
     }
     /* Open file */
     fp = tftp_file_open(local_name, _private->xfer->mode, 1);
     if (fp == NULL)
     {
         tftp_printf("open file \"%s\" error.\n", local_name);
+        client->err = -TFTP_EFILE;
         return -TFTP_EFILE;
     }
     pack = malloc(sizeof(struct tftp_packet));
     if (pack == NULL)
     {
         tftp_transfer_err(_private->xfer, 0, "malloc pack failed!");
         tftp_file_close(fp);
+        client->err = -TFTP_EMEM;
         return -TFTP_EMEM;
     }
     while (1)
@@ -166,6 +174,7 @@ int tftp_client_push(struct tftp_client *client, const char *local_name, const c
         if (r_size < 0)
         {
             max_retry = 0;
+            client->err = -TFTP_EFILE;
             break;
         }
         max_retry = client->max_retry;
@@ -177,6 +186,7 @@ int tftp_client_push(struct tftp_client *client, const char *local_name, const c
             {
                 tftp_transfer_err(_private->xfer, 0, "send file err!");
                 max_retry = 0;
+                client->err = -TFTP_EDATA;
                 break;
             }
             /* Wait server ACK */
@@ -188,14 +198,15 @@ int tftp_client_push(struct tftp_client *client, const char *local_name, const c
             }
             else if (res == -TFTP_ETIMEOUT)
             {
-                tftp_printf("tftp selct timeout. retry\n");
+                tftp_printf("tftp wait response timeout. retry\n");
                 max_retry --;
                 continue;
             }
             else
             {
-                tftp_printf("tftp selct err:%d. exit\n", res);
+                tftp_printf("tftp wait response err:%d. exit\n", res);
                 max_retry = 0;
+                client->err = res;
                 break;
             }
         }
@@ -208,6 +219,7 @@ int tftp_client_push(struct tftp_client *client, const char *local_name, const c
         if (tftp_wait_ack(_private->xfer) != TFTP_OK)
         {
             tftp_printf("wait ack failed!! exit\n");
+            client->err = -TFTP_EACK;
             break;
         }
         file_size += r_size;
@@ -234,6 +246,7 @@ int tftp_client_pull(struct tftp_client *client, const char *remote_name, const
 
     _private = client->_private;
     max_retry = client->max_retry;
+    client->err = TFTP_OK;
     while (max_retry)
     {
         /* Send Read File Request */
@@ -242,6 +255,7 @@ int tftp_client_pull(struct tftp_client *client, const char *remote_name, const
         {
             tftp_printf("tftp send request failed !! retry:%d. exit\n", max_retry);
             max_retry = 0;
+            client->err = res;
             break;
         }
         /* Waiting for the server to respond to the request */
@@ -253,16 +267,17 @@ int tftp_client_pull(struct tftp_client *client, const char *remote_name, const
         }
         else if (res == -TFTP_ETIMEOUT)
         {
-            tftp_printf("tftp selct timeout. retry\n");
+            tftp_printf("tftp wait response timeout. retry\n");
             max_retry --;
             continue;
         }
         else
         {
-            tftp_printf("tftp selct err:%d. exit\n", res);
+            tftp_printf("tftp wait response err:%d. exit\n", res);
             max_retry = 0;
+            client->err = res;
             break;
-        }        
+        }
     }
 
     /* More than the maximum number of retries. exit */
@@ -276,6 +291,7 @@ int tftp_client_pull(struct tftp_client *client, const char *remote_name, const
     if (fp == NULL)
     {
         tftp_printf("open file \"%s\" error.\n", local_name);
+        client->err = -TFTP_EFILE;
         return -TFTP_EFILE;
     }
     pack = malloc(sizeof(struct tftp_packet));
@@ -284,6 +300,7 @@ int tftp_client_pull(struct tftp_client *client, const char *remote_name, const
         /* malloc failed. send err msg and exit */
         tftp_transfer_err(_private->xfer, 0, "malloc pack failed!");
         tftp_file_close(fp);
+        client->err = -TFTP_EMEM;
         return -TFTP_EMEM;
     }
     while (1)
@@ -294,6 +311,7 @@ int tftp_client_pull(struct tftp_client *client, const char *remote_name, const
         if (recv_size < 0)
         {
             tftp_printf("read data err[%d]! exit\n", recv_size);
+            client->err = -TFTP_EDATA;
             break;
         }
         /* Write data to file */
@@ -302,6 +320,7 @@ int tftp_client_pull(struct tftp_client *client, const char *remote_name, const
         {
             tftp_printf("write file err! exit\n");
             tftp_transfer_err(_private->xfer, 0, "write file err!");
+            client->err = -TFTP_EFILE;
             break;
         }
         file_size += recv_size;
@@ -324,13 +343,14 @@ int tftp_client_pull(struct tftp_client *client, const char *remote_name, const
             }
             else if (res == -TFTP_ETIMEOUT)
             {
-                tftp_printf("tftp selct timeout. retry\n");
+                tftp_printf("tftp wait response timeout. retry\n");
                 max_retry --;
             }
             else
             {
-                tftp_printf("tftp selct err:%d. exit\n", res);
+                tftp_printf("tftp wait response err:%d. exit\n", res);
                 max_retry = 0;
+                client->err = res;
                 break;
             }
         }
@@ -344,3 +364,8 @@ int tftp_client_pull(struct tftp_client *client, const char *remote_name, const
     free(pack);
     return file_size;
 }
+
+int tftp_client_err(struct tftp_client *client)
+{
+    return client->err;
+}
diff --git a/tftp/tftp_xfer.c b/tftp/tftp_xfer.c
@@ -202,9 +202,11 @@ int tftp_send_request(struct tftp_xfer *xfer, uint16_t cmd, const char *remote_f
     }
     /* Packing request packet header */
     send_packet->cmd = htons(cmd);
-    size = sprintf(send_packet->info.filename, "%s%c%s%c%d%c", remote_file, 0, xfer->mode, 0, xfer->blksize, 0) + 3;
+    size = sprintf(send_packet->info.filename, "%s%c%s%c%s%c%d%c%s%c%d%c",
+        remote_file, 0, xfer->mode, 0, "blksize", 0, xfer->blksize, 0,"tsize", 0, 0, 0) + 2;
     /* send data */
-    r_size = sendto(xfer->sock, send_packet, size, 0, (struct sockaddr *)&_private->server, sizeof(struct sockaddr_in));
+    r_size = sendto(xfer->sock, send_packet, size, 0,
+        (struct sockaddr *)&_private->server, sizeof(struct sockaddr_in));
     free(send_packet);
     if (size != r_size)
     {

Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,8 @@ struct tftp_client tftp_client_create(const char ip_addr, int port)`
`74`	`74`	`}`
`75`	`75`	`/* Number of Initial Retries */`
`76`	`76`	`client->max_retry = TFTP_MAX_RETRY;`
	`77`	`+ /* Initialization error number */`
	`78`	`+ client->err = TFTP_OK;`
`77`	`79`	`/* Binding Private Data */`
`78`	`80`	`client->_private = _private;`
`79`	`81`	`return client;`
`@@ -102,6 +104,7 @@ int tftp_client_push(struct tftp_client client, const char local_name, const c`
`102`	`104`
`103`	`105`	`_private = client->_private;`
`104`	`106`	`max_retry = client->max_retry;`
	`107`	`+ client->err = TFTP_OK;`
`105`	`108`	`while (max_retry)`
`106`	`109`	`{`
`107`	`110`	`/* Send Write Request */`
`@@ -110,6 +113,7 @@ int tftp_client_push(struct tftp_client client, const char local_name, const c`
`110`	`113`	`{`
`111`	`114`	`tftp_printf("tftp send request failed !! retry:%d. exit\n", client->max_retry - max_retry);`
`112`	`115`	`max_retry = 0;`
	`116`	`+ client->err = res;`
`113`	`117`	`break;`
`114`	`118`	`}`
`115`	`119`	`/* Waiting for server response */`
`@@ -121,15 +125,16 @@ int tftp_client_push(struct tftp_client client, const char local_name, const c`
`121`	`125`	`}`
`122`	`126`	`else if (res == -TFTP_ETIMEOUT)`
`123`	`127`	`{`
`124`		`- tftp_printf("tftp selct timeout. retry\n");`
	`128`	`+ tftp_printf("tftp wait response timeout. retry\n");`
`125`	`129`	`max_retry --;`
`126`	`130`	`continue;`
`127`	`131`	`}`
`128`	`132`	`else`
`129`	`133`	`{`
`130`	`134`	`/* Waiting for Response Error */`
`131`		`- tftp_printf("tftp selct err:%d. exit\n", res);`
	`135`	`+ tftp_printf("tftp wait response err:%d. exit\n", res);`
`132`	`136`	`max_retry = 0;`
	`137`	`+ client->err = res;`
`133`	`138`	`break;`
`134`	`139`	`}`
`135`	`140`	`}`
`@@ -143,20 +148,23 @@ int tftp_client_push(struct tftp_client client, const char local_name, const c`
`143`	`148`	`if (res != TFTP_OK)`
`144`	`149`	`{`
`145`	`150`	`tftp_printf("wait ack failed!! exit\n");`
	`151`	`+ client->err = res;`
`146`	`152`	`return res;`
`147`	`153`	`}`
`148`	`154`	`/* Open file */`
`149`	`155`	`fp = tftp_file_open(local_name, _private->xfer->mode, 1);`
`150`	`156`	`if (fp == NULL)`
`151`	`157`	`{`
`152`	`158`	`tftp_printf("open file \"%s\" error.\n", local_name);`
	`159`	`+ client->err = -TFTP_EFILE;`
`153`	`160`	`return -TFTP_EFILE;`
`154`	`161`	`}`
`155`	`162`	`pack = malloc(sizeof(struct tftp_packet));`
`156`	`163`	`if (pack == NULL)`
`157`	`164`	`{`
`158`	`165`	`tftp_transfer_err(_private->xfer, 0, "malloc pack failed!");`
`159`	`166`	`tftp_file_close(fp);`
	`167`	`+ client->err = -TFTP_EMEM;`
`160`	`168`	`return -TFTP_EMEM;`
`161`	`169`	`}`
`162`	`170`	`while (1)`
`@@ -166,6 +174,7 @@ int tftp_client_push(struct tftp_client client, const char local_name, const c`
`166`	`174`	`if (r_size < 0)`
`167`	`175`	`{`
`168`	`176`	`max_retry = 0;`
	`177`	`+ client->err = -TFTP_EFILE;`
`169`	`178`	`break;`
`170`	`179`	`}`
`171`	`180`	`max_retry = client->max_retry;`
`@@ -177,6 +186,7 @@ int tftp_client_push(struct tftp_client client, const char local_name, const c`
`177`	`186`	`{`
`178`	`187`	`tftp_transfer_err(_private->xfer, 0, "send file err!");`
`179`	`188`	`max_retry = 0;`
	`189`	`+ client->err = -TFTP_EDATA;`
`180`	`190`	`break;`
`181`	`191`	`}`
`182`	`192`	`/* Wait server ACK */`
`@@ -188,14 +198,15 @@ int tftp_client_push(struct tftp_client client, const char local_name, const c`
`188`	`198`	`}`
`189`	`199`	`else if (res == -TFTP_ETIMEOUT)`
`190`	`200`	`{`
`191`		`- tftp_printf("tftp selct timeout. retry\n");`
	`201`	`+ tftp_printf("tftp wait response timeout. retry\n");`
`192`	`202`	`max_retry --;`
`193`	`203`	`continue;`
`194`	`204`	`}`
`195`	`205`	`else`
`196`	`206`	`{`
`197`		`- tftp_printf("tftp selct err:%d. exit\n", res);`
	`207`	`+ tftp_printf("tftp wait response err:%d. exit\n", res);`
`198`	`208`	`max_retry = 0;`
	`209`	`+ client->err = res;`
`199`	`210`	`break;`
`200`	`211`	`}`
`201`	`212`	`}`
`@@ -208,6 +219,7 @@ int tftp_client_push(struct tftp_client client, const char local_name, const c`
`208`	`219`	`if (tftp_wait_ack(_private->xfer) != TFTP_OK)`
`209`	`220`	`{`
`210`	`221`	`tftp_printf("wait ack failed!! exit\n");`
	`222`	`+ client->err = -TFTP_EACK;`
`211`	`223`	`break;`
`212`	`224`	`}`
`213`	`225`	`file_size += r_size;`
`@@ -234,6 +246,7 @@ int tftp_client_pull(struct tftp_client client, const char remote_name, const`
`234`	`246`
`235`	`247`	`_private = client->_private;`
`236`	`248`	`max_retry = client->max_retry;`
	`249`	`+ client->err = TFTP_OK;`
`237`	`250`	`while (max_retry)`
`238`	`251`	`{`
`239`	`252`	`/* Send Read File Request */`
`@@ -242,6 +255,7 @@ int tftp_client_pull(struct tftp_client client, const char remote_name, const`
`242`	`255`	`{`
`243`	`256`	`tftp_printf("tftp send request failed !! retry:%d. exit\n", max_retry);`
`244`	`257`	`max_retry = 0;`
	`258`	`+ client->err = res;`
`245`	`259`	`break;`
`246`	`260`	`}`
`247`	`261`	`/* Waiting for the server to respond to the request */`
`@@ -253,16 +267,17 @@ int tftp_client_pull(struct tftp_client client, const char remote_name, const`
`253`	`267`	`}`
`254`	`268`	`else if (res == -TFTP_ETIMEOUT)`
`255`	`269`	`{`
`256`		`- tftp_printf("tftp selct timeout. retry\n");`
	`270`	`+ tftp_printf("tftp wait response timeout. retry\n");`
`257`	`271`	`max_retry --;`
`258`	`272`	`continue;`
`259`	`273`	`}`
`260`	`274`	`else`
`261`	`275`	`{`
`262`		`- tftp_printf("tftp selct err:%d. exit\n", res);`
	`276`	`+ tftp_printf("tftp wait response err:%d. exit\n", res);`
`263`	`277`	`max_retry = 0;`
	`278`	`+ client->err = res;`
`264`	`279`	`break;`
`265`		`- }`
	`280`	`+ }`
`266`	`281`	`}`
`267`	`282`
`268`	`283`	`/* More than the maximum number of retries. exit */`
`@@ -276,6 +291,7 @@ int tftp_client_pull(struct tftp_client client, const char remote_name, const`
`276`	`291`	`if (fp == NULL)`
`277`	`292`	`{`
`278`	`293`	`tftp_printf("open file \"%s\" error.\n", local_name);`
	`294`	`+ client->err = -TFTP_EFILE;`
`279`	`295`	`return -TFTP_EFILE;`
`280`	`296`	`}`
`281`	`297`	`pack = malloc(sizeof(struct tftp_packet));`
`@@ -284,6 +300,7 @@ int tftp_client_pull(struct tftp_client client, const char remote_name, const`
`284`	`300`	`/* malloc failed. send err msg and exit */`
`285`	`301`	`tftp_transfer_err(_private->xfer, 0, "malloc pack failed!");`
`286`	`302`	`tftp_file_close(fp);`
	`303`	`+ client->err = -TFTP_EMEM;`
`287`	`304`	`return -TFTP_EMEM;`
`288`	`305`	`}`
`289`	`306`	`while (1)`
`@@ -294,6 +311,7 @@ int tftp_client_pull(struct tftp_client client, const char remote_name, const`
`294`	`311`	`if (recv_size < 0)`
`295`	`312`	`{`
`296`	`313`	`tftp_printf("read data err[%d]! exit\n", recv_size);`
	`314`	`+ client->err = -TFTP_EDATA;`
`297`	`315`	`break;`
`298`	`316`	`}`
`299`	`317`	`/* Write data to file */`
`@@ -302,6 +320,7 @@ int tftp_client_pull(struct tftp_client client, const char remote_name, const`
`302`	`320`	`{`
`303`	`321`	`tftp_printf("write file err! exit\n");`
`304`	`322`	`tftp_transfer_err(_private->xfer, 0, "write file err!");`
	`323`	`+ client->err = -TFTP_EFILE;`
`305`	`324`	`break;`
`306`	`325`	`}`
`307`	`326`	`file_size += recv_size;`
`@@ -324,13 +343,14 @@ int tftp_client_pull(struct tftp_client client, const char remote_name, const`
`324`	`343`	`}`
`325`	`344`	`else if (res == -TFTP_ETIMEOUT)`
`326`	`345`	`{`
`327`		`- tftp_printf("tftp selct timeout. retry\n");`
	`346`	`+ tftp_printf("tftp wait response timeout. retry\n");`
`328`	`347`	`max_retry --;`
`329`	`348`	`}`
`330`	`349`	`else`
`331`	`350`	`{`
`332`		`- tftp_printf("tftp selct err:%d. exit\n", res);`
	`351`	`+ tftp_printf("tftp wait response err:%d. exit\n", res);`
`333`	`352`	`max_retry = 0;`
	`353`	`+ client->err = res;`
`334`	`354`	`break;`
`335`	`355`	`}`
`336`	`356`	`}`
`@@ -344,3 +364,8 @@ int tftp_client_pull(struct tftp_client client, const char remote_name, const`
`344`	`364`	`free(pack);`
`345`	`365`	`return file_size;`
`346`	`366`	`}`
	`367`	`+`
	`368`	`+int tftp_client_err(struct tftp_client *client)`
	`369`	`+{`
	`370`	`+ return client->err;`
	`371`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -202,9 +202,11 @@ int tftp_send_request(struct tftp_xfer xfer, uint16_t cmd, const char remote_f`
`202`	`202`	`}`
`203`	`203`	`/* Packing request packet header */`
`204`	`204`	`send_packet->cmd = htons(cmd);`
`205`		`- size = sprintf(send_packet->info.filename, "%s%c%s%c%d%c", remote_file, 0, xfer->mode, 0, xfer->blksize, 0) + 3;`
	`205`	`+ size = sprintf(send_packet->info.filename, "%s%c%s%c%s%c%d%c%s%c%d%c",`
	`206`	`+ remote_file, 0, xfer->mode, 0, "blksize", 0, xfer->blksize, 0,"tsize", 0, 0, 0) + 2;`
`206`	`207`	`/* send data */`
`207`		`- r_size = sendto(xfer->sock, send_packet, size, 0, (struct sockaddr *)&_private->server, sizeof(struct sockaddr_in));`
	`208`	`+ r_size = sendto(xfer->sock, send_packet, size, 0,`
	`209`	`+ (struct sockaddr *)&_private->server, sizeof(struct sockaddr_in));`
`208`	`210`	`free(send_packet);`
`209`	`211`	`if (size != r_size)`
`210`	`212`	`{`