Chinaunix首页 | 论坛 | 博客

平空

首页　| 　博文目录　| 　关于我

zzbok

  • 博客访问： 1334825
  • 博文数量： 198
  • 博客积分： 1629
  • 博客等级： 上尉
  • 技术积分： 2743
  • 用 户 组： 普通用户
  • 注册时间： 2011-08-01 15:41
文章分类

全部博文（198）

文章存档

2023年（6）

2022年（20）

2021年（8）

2020年（3）

2018年（17）

2017年（3）

2016年（3）

2015年（9）

2014年（13）

2013年（17）

2012年（77）

2011年（22）

我的朋友
最近访客
推荐博文
相关博文
产品固件(系统)升级——curl/wget

分类： LINUX

2022-03-25 14:33:56

1、文件下载指令应用

支持断点续传

curl -C - -O "https://curl.haxx.se/download/archeology/curl-7.58.0.tar.gz"
curl -C - -O "https://curl.haxx.se/download/archeology/md5.txt"
直接覆盖
curl "https://curl.haxx.se/download/archeology/curl-7.58.0.tar.gz" -o curl-7.58.0.tar.gz --progress
curl "https://curl.haxx.se/download/archeology/md5.txt" -o md5.txt --progress

系统自带的wget指令下载文件也类似

wget "https://curl.haxx.se/download/archeology/curl-7.58.0.tar.gz"
wget -O curl-7.58.0.tar.gz "https://curl.haxx.se/download/archeology/curl-7.58.0.tar.gz"

 

2、产品固件更新应用demo

upgrade.sh

点击(此处)折叠或打开

  1. #!/bin/sh
  2. url="https://curl.haxx.se/download/archeology/"
  3. while true
  4. do
  5.     #1)download file
  6.     md5_url=${url}"md5.txt"
  7.     #curl md5_url -o md5.txt --progress
  8.     wget -O md5.txt "$md5_url"
  9.     version=$(sed -n 1p md5.txt)
  10.     filename=$(sed -n 2p md5.txt)
  11.     md5=$(sed -n 3p md5.txt)
  12.     version_bak=$(sed -n 1p md5_bak.txt)
  13.     
  14.     echo $version
  15.     echo $filename
  16.     echo $md5
  17.     echo $version_bak
  18.     
  19.     #2)md5sum firmware
  20.     if [[ "$version" != "$version_bak" ]];then
  21.         cp md5.txt md5_bak.txt
  22.         download_url=${url}${filename}
  23.         download_url=${download_url%$'\r'}
  24.         #curl "$download_url" -o $filename --progress
  25.         wget -O $filename "$download_url"
  26.         md5_calc=$(md5sum $filename|cut -d ' ' -f1)

  28.         #3)replace app file---> reboot
  29.         if [ "$md5"=="$md5_calc" ] ; then
  30.             ./kill_app.sh
  31.             #replace upgrade file
  32.             ./run_app.sh
  33.             rm $filename
  34.             time=$(date "+%Y-%m-%d %H:%M:%S")
  35.             echo "${time} upgrade $md5_calc $filename " >> log.txt
  36.         else
  37.             echo "upgrade file md5sum err !"
  38.         fi
  39.     else
  40.         echo "local version is the latest version !"
  41.     fi
  42.     sleep 10
  43. done

3、 md5.txt

 md5.txt文件内置3行关键信息

7.58.0
curl-7.58.0.tar.gz
7e9e9d5405c61148d53035426f162b0a

 

4、curl安装

https://curl.haxx.se/

./configure --prefix=/usr/local/curl
make
sudo make install

export PATH=$PATH:/usr/local/curl/bin
export LD_LIBRARY_PATH=/usr/local/curl/lib:$LD_LIBRARY_PATH

 

5、curl移植

./configure --prefix=/home/dong/curl/curl-7.58.0/_install --host=arm-linux-gnueabihf CC=arm-linux-gnueabihf-gcc CXX=arm-linux-gnueabihf-g++
make
sudo make install

 

6、 wget编译，安装

# tar zxvf wget-1.9.1.tar.gz 

# cd wget-1.9.1 

# ./configure 

# make 

# make install

 

7、progress

点击(此处)折叠或打开

  1. wget -c https://ftp.gnu.org/gnu/wget/wget-1.19.tar.gz -o load.log
progress.sh

点击(此处)折叠或打开

  1. #wget -c https://ftp.gnu.org/gnu/wget/wget-1.19.tar.gz -o load.log

  3. while true
  4. do

  6. sed -n '/..........\>/p' load.log | sed '$d' | sed -n '$p' | awk '{print $1,$2,$3,$4,$5,$6,$7}'
  7. sed -n '/...\>/p' load.log | sed '$d' | sed -n '$p' | awk '{print $1,$2,$3,$4}'

  9. sleep 1

  11. done

8、progress.c

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. //类似wget的进度条的实现，实际就是转移符\r的使用，\r的作用是返回至行首而不换行
  5. int main(int argc, char *argv[])
  6. {
  7.     unsigned len = 60;
  8.     char *bar = (char *)malloc(sizeof(char) * (len + 1));
  9.     for (int i = 0; i < len + 1; ++i)
  10.     {
  11.         bar[i] = '#';
  12.     }
  13.     for (int i = 0; i < len; ++i)
  14.     {
  15.         printf("progress:[%s]%d%%\r", bar+len-i, i+1);
  16.         fflush(stdout);//一定要fflush，否则不会会因为缓冲无法定时输出。
  17.         usleep(100000);
  18.         //sleep(1);
  19.     }
  20.     printf("\n");
  21.     return 0;
  22. }

9、checkurl.sh

点击(此处)折叠或打开

  1. #!/bin/bash
  2. usage(){
  3.     echo "Usage:$0 url"
  4.     exit 1
  5. }

  7. checkurl(){

  9.     local num=`curl -I -m 5 -s -w "%{http_code}\n" -o /dev/null $1 |egrep "(200|301|302)"|wc -l`

  11.     if [ $num -eq 1 ]
  12.     then
  13.          echo "ok"
  14.     else
  15.          echo "$1"
  16.     fi
  17. }

  19. main(){

  21.     if [ $# -ne 1 ]
  22.     then
  23.         usage
  24.     fi

  26.     checkurl $1

  28. }

  30. main $*

sh checkurl.sh

10、c语言文件下载，带进度条

https://blog.csdn.net/qq_31629063/article/details/80846673

https://www.cnblogs.com/wainiwann/p/3148884.html


url2file.c

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <arpa/inet.h>
  5. #include <sys/types.h>
  6. #include <sys/socket.h>
  7. #include <fcntl.h>
  8. #include <unistd.h>
  9. #include <netdb.h>
  10. #include <errno.h>

  12. #define HOST_NAME_LEN 256
  13. #define URI_MAX_LEN 2048
  14. #define RECV_BUF 8192
  15. #define RCV_SND_TIMEOUT (10*1000) //收发数据超时时间(ms)

  17. typedef struct {
  18.     int sock; //与服务器通信的socket
  19.     FILE *in; //sock描述符转为文件指针，方便读写
  20.     char host_name[HOST_NAME_LEN]; //主机名
  21.     int port; //主机端口号
  22.     char uri[URI_MAX_LEN]; //资源路径
  23.     char buffer[RECV_BUF]; //读写缓冲
  24.     int status_code; //http状态码
  25.     int chunked_flag; //chunked传输的标志位
  26.     int len; //Content-length里的长度
  27.     char location[URI_MAX_LEN]; //重定向地址
  28.     char *save_path; //保存内容的路径指针
  29.     FILE *save_file; //保存内容的文件指针
  30.     int recv_data_len; //收到数据的总长度
  31.     time_t start_recv_time; //开始接受数据的时间
  32.     time_t end_recv_time; //结束接受数据的时间
  33. } http_t;

  35. /* 打印宏 */
  36. #define MSG_DEBUG 0x01
  37. #define MSG_INFO 0x02
  38. #define MSG_ERROR 0x04

  40. static int print_level = /*MSG_DEBUG |*/ MSG_INFO | MSG_ERROR;

  42. #define lprintf(level, format, argv...) do{ \
  43.     if(level & print_level) \
  44.         printf("[%s][%s(%d)]:"format, #level, __FUNCTION__, __LINE__, ##argv); \
  45. }while(0)

  47. #define MIN(x, y) ((x) > (y) ? (y) : (x))

  49. #define HTTP_OK 200
  50. #define HTTP_REDIRECT 302
  51. #define HTTP_NOT_FOUND 404

  53. /* 不区分大小写的strstr */
  54. char *strncasestr(char *str, char *sub)
  55. {
  56.     if(!str || !sub)
  57.         return NULL;

  59.     int len = strlen(sub);
  60.     if (len == 0)
  61.     {
  62.         return NULL;
  63.     }

  65.     while (*str)
  66.     {
  67.         if (strncasecmp(str, sub, len) == 0)
  68.         {
  69.             return str;
  70.         }
  71.         ++str;
  72.     }
  73.     return NULL;
  74. }

  76. /* 解析URL, 成功返回0，失败返回-1 */
  77. /* http://127.0.0.1:8080/testfile */
  78. int parser_URL(char *url, http_t *info)
  79. {
  80.     char *tmp = url, *start = NULL, *end = NULL;
  81.     int len = 0;

  83.     /* 跳过http:// */
  84.     if(strncasestr(tmp, "http://"))
  85.     {
  86.         tmp += strlen("http://");
  87.     }
  88.     start = tmp;
  89.     if(!(tmp = strchr(start, '/')))
  90.     {
  91.         lprintf(MSG_ERROR, "url invaild\n");
  92.         return -1;
  93.     }
  94.     end = tmp;

  96.     /*解析端口号和主机*/
  97.     info->port = 80; //先附默认值80

  99.     len = MIN(end - start, HOST_NAME_LEN - 1);
  100.     strncpy(info->host_name, start, len);
  101.     info->host_name[len] = '\0';

  103.     if((tmp = strchr(start, ':')) && tmp < end)
  104.     {
  105.         info->port = atoi(tmp + 1);
  106.         if(info->port <= 0 || info->port >= 65535)
  107.         {
  108.             lprintf(MSG_ERROR, "url port invaild\n");
  109.             return -1;
  110.         }
  111.         /* 覆盖之前的赋值 */
  112.         len = MIN(tmp - start, HOST_NAME_LEN - 1);
  113.         strncpy(info->host_name, start, len);
  114.         info->host_name[len] = '\0';
  115.     }

  117.     /* 复制uri */
  118.     start = end;
  119.     strncpy(info->uri, start, URI_MAX_LEN - 1);

  121.     lprintf(MSG_INFO, "parse url ok\nhost:%s, port:%d, uri:%s\n",
  122.         info->host_name, info->port, info->uri);
  123.     return 0;
  124. }

  126. /* dns解析,返回解析到的第一个地址，失败返回-1，成功则返回相应地址 */
  127. unsigned long dns(char* host_name)
  128. {

  130.     struct hostent* host;
  131.     struct in_addr addr;
  132.     char **pp;

  134.     host = gethostbyname(host_name);
  135.     if (host == NULL)
  136.     {
  137.         lprintf(MSG_ERROR, "gethostbyname %s failed\n", host_name);
  138.         return -1;
  139.     }

  141.     pp = host->h_addr_list;

  143.     if (*pp!=NULL)
  144.     {
  145.         addr.s_addr = *((unsigned int *)*pp);
  146.         lprintf(MSG_INFO, "%s address is %s\n", host_name, inet_ntoa(addr));
  147.         pp++;
  148.         return addr.s_addr;
  149.     }

  151.     return -1;
  152. }

  154. /* 设置发送接收超时 */
  155. int set_socket_option(int sock)
  156. {
  157.     struct timeval timeout;

  159.     timeout.tv_sec = RCV_SND_TIMEOUT/1000;
  160.     timeout.tv_usec = RCV_SND_TIMEOUT%1000*1000;
  161.     lprintf(MSG_DEBUG, "%ds %dus\n", (int)timeout.tv_sec, (int)timeout.tv_usec);
  162.     //设置socket为非阻塞
  163.     // fcntl(sock ,F_SETFL, O_NONBLOCK); //以非阻塞的方式，connect需要重新处理

  165.     // 设置发送超时
  166.     if(-1 == setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout,
  167.             sizeof(struct timeval)))
  168.     {
  169.         lprintf(MSG_ERROR, "setsockopt error: %m\n");
  170.         return -1;
  171.     }

  173.     // 设置接送超时
  174.     if(-1 == setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout,
  175.             sizeof(struct timeval)))
  176.     {
  177.         lprintf(MSG_ERROR, "setsockopt error: %m\n");
  178.         return -1;
  179.     }

  181.     return 0;
  182. }

  184. /* 连接到服务器 */
  185. int connect_server(http_t *info)
  186. {
  187.     int sockfd;
  188.     struct sockaddr_in server;
  189.     unsigned long addr = 0;
  190.     unsigned short port = info->port;

  192.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
  193.     if (-1 == sockfd)
  194.     {
  195.         lprintf(MSG_ERROR, "socket create failed\n");
  196.         goto failed;
  197.     }

  199.     if(-1 == set_socket_option(sockfd))
  200.     {
  201.         goto failed;
  202.     }

  204.     if ((addr = dns(info->host_name)) == -1)
  205.     {
  206.         lprintf(MSG_ERROR, "Get Dns Failed\n");
  207.         goto failed;
  208.     }
  209.     memset(&server, 0, sizeof(server));
  210.     server.sin_family = AF_INET;
  211.     server.sin_port = htons(port);
  212.     server.sin_addr.s_addr = addr;

  214.     if (-1 == connect(sockfd, (struct sockaddr *)&server, sizeof(struct sockaddr)))
  215.     {
  216.         lprintf(MSG_ERROR, "connect failed: %m\n");
  217.         goto failed;
  218.     }

  220.     info->sock = sockfd;
  221.     return 0;

  223. failed:
  224.     if(sockfd != -1)
  225.         close(sockfd);
  226.     return -1;
  227. }

  229. /* 发送http请求 */
  230. int send_request(http_t *info)
  231. {
  232.     int len;

  234.     memset(info->buffer, 0x0, RECV_BUF);
  235.     snprintf(info->buffer, RECV_BUF - 1, "GET %s HTTP/1.1\r\n"
  236.         "Accept: */*\r\n"
  237.         "User-Agent: Mozilla/5.0 (compatible; MSIE 5.01; Windows NT 5.0)\r\n"
  238.         "Host: %s\r\n"
  239.         "Connection: Close\r\n\r\n", info->uri, info->host_name);

  241.     lprintf(MSG_DEBUG, "request:\n%s\n", info->buffer);
  242.     return send(info->sock, info->buffer, strlen(info->buffer), 0);
  243. }

  245. /* 解析http头 */
  246. int parse_http_header(http_t *info)
  247. {
  248.     char *p = NULL;

  250.     // 解析第一行
  251.     fgets(info->buffer, RECV_BUF, info->in);
  252.     p = strchr(info->buffer, ' ');
  253.     //简单检查http头第一行是否合法
  254.     if(!p || !strcasestr(info->buffer, "HTTP"))
  255.     {
  256.         lprintf(MSG_ERROR, "bad http head\n");
  257.         return -1;
  258.     }
  259.     info->status_code = atoi(p + 1);
  260.     lprintf(MSG_DEBUG, "http status code: %d\n", info->status_code);

  262.     // 循环读取解析http头
  263.     while(fgets(info->buffer, RECV_BUF, info->in))
  264.     {
  265.         // 判断头部是否读完
  266.         if(!strcmp(info->buffer, "\r\n"))
  267.         {
  268.             return 0; /* 头解析正常 */
  269.         }
  270.         lprintf(MSG_DEBUG, "%s", info->buffer);
  271.         // 解析长度 Content-length: 554
  272.         if(p = strncasestr(info->buffer, "Content-length"))
  273.         {
  274.             p = strchr(p, ':');
  275.             p += 2; // 跳过冒号和后面的空格
  276.             info->len = atoi(p);
  277.             lprintf(MSG_INFO, "Content-length: %d\n", info->len);
  278.         }
  279.         else if(p = strncasestr(info->buffer, "Transfer-Encoding"))
  280.         {
  281.             if(strncasestr(info->buffer, "chunked"))
  282.             {
  283.                 info->chunked_flag = 1;
  284.             }
  285.             else
  286.             {
  287.                 /* 不支持其他编码的传送方式 */
  288.                 lprintf(MSG_ERROR, "Not support %s", info->buffer);
  289.                 return -1;
  290.             }
  291.             lprintf(MSG_INFO, "%s", info->buffer);
  292.         }
  293.         else if(p = strncasestr(info->buffer, "Location"))
  294.         {
  295.             p = strchr(p, ':');
  296.             p += 2; // 跳过冒号和后面的空格
  297.             strncpy(info->location, p, URI_MAX_LEN - 1);
  298.             lprintf(MSG_INFO, "Location: %s\n", info->location);
  299.         }
  300.     }
  301.     lprintf(MSG_ERROR, "bad http head\n");
  302.     return -1; /* 头解析出错 */
  303. }

  305. /* 保存服务器响应的内容 */
  306. int save_data(http_t *info, const char *buf, int len)
  307. {
  308.     int total_len = len;
  309.     int write_len = 0;

  311.     // 文件没有打开则先打开
  312.     if(!info->save_file)
  313.     {
  314.         info->save_file = fopen(info->save_path, "w");
  315.         if(!info->save_file)
  316.         {
  317.             lprintf(MSG_ERROR, "fopen %s error: %m\n", info->save_path);
  318.             return -1;
  319.         }
  320.     }

  322.     while(total_len)
  323.     {
  324.         write_len = fwrite(buf, sizeof(char), len, info->save_file);
  325.         if(write_len < len && errno != EINTR)
  326.         {
  327.             lprintf(MSG_ERROR, "fwrite error: %m\n");
  328.             return -1;
  329.         }
  330.         total_len -= write_len;
  331.     }
  332. }

  334. /* 读数据 */
  335. int read_data(http_t *info, int len)
  336. {
  337.     int total_len = len;
  338.     int read_len = 0;
  339.     int rtn_len = 0;

  341.     while(total_len)
  342.     {
  343.         read_len = MIN(total_len, RECV_BUF);
  344.         // lprintf(MSG_DEBUG, "need read len: %d\n", read_len);
  345.         rtn_len = fread(info->buffer, sizeof(char), read_len, info->in);
  346.         if(rtn_len < read_len)
  347.         {
  348.             if(ferror(info->in))
  349.             {
  350.                 if(errno == EINTR) /* 信号中断了读操作 */
  351.                 {
  352.                     ; /* 不做处理继续往下走 */
  353.                 }
  354.                 else if(errno == EAGAIN || errno == EWOULDBLOCK) /* 超时 */
  355.                 {
  356.                     lprintf(MSG_ERROR, "socket recvice timeout: %dms\n", RCV_SND_TIMEOUT);
  357.                     total_len -= rtn_len;
  358.                     lprintf(MSG_DEBUG, "read len: %d\n", rtn_len);
  359.                     break;
  360.                 }
  361.                 else /* 其他错误 */
  362.                 {
  363.                     lprintf(MSG_ERROR, "fread error: %m\n");
  364.                     break;
  365.                 }
  366.             }
  367.             else /* 读到文件尾 */
  368.             {
  369.                 lprintf(MSG_ERROR, "socket closed by peer\n");
  370.                 total_len -= rtn_len;
  371.                 lprintf(MSG_DEBUG, "read len: %d\n", rtn_len);
  372.                 break;
  373.             }
  374.         }

  376.         // lprintf(MSG_DEBUG, " %s\n", info->buffer);
  377.         total_len -= rtn_len;
  378.         lprintf(MSG_DEBUG, "read len: %d\n", rtn_len);
  379.         if(-1 == save_data(info, info->buffer, rtn_len))
  380.         {
  381.             return -1;
  382.         }
  383.         info->recv_data_len += rtn_len;
  384.     }
  385.     if(total_len != 0)
  386.     {
  387.         lprintf(MSG_ERROR, "we need to read %d bytes, but read %d bytes now\n",
  388.             len, len - total_len);
  389.         return -1;
  390.     }
  391. }

  393. /* 接收服务器发回的chunked数据 */
  394. int recv_chunked_response(http_t *info)
  395. {
  396.     long part_len;

  398.     //有chunked，content length就没有了
  399.     do{
  400.         // 获取这一个部分的长度
  401.         fgets(info->buffer, RECV_BUF, info->in);
  402.         part_len = strtol(info->buffer, NULL, 16);
  403.         lprintf(MSG_DEBUG, "part len: %ld\n", part_len);
  404.         if(-1 == read_data(info, part_len))
  405.             return -1;

  407.         //读走后面的\r\n两个字符
  408.         if(2 != fread(info->buffer, sizeof(char), 2, info->in))
  409.         {
  410.             lprintf(MSG_ERROR, "fread \\r\\n error : %m\n");
  411.             return -1;
  412.         }
  413.     }while(part_len);
  414.     return 0;
  415. }

  417. /* 计算平均下载速度，单位byte/s */
  418. float calc_download_speed(http_t *info)
  419. {
  420.     int diff_time = 0;
  421.     float speed = 0.0;

  423.     diff_time = info->end_recv_time - info->start_recv_time;
  424.     /* 最小间隔1s，避免计算浮点数结果为inf */
  425.     if(0 == diff_time)
  426.         diff_time = 1;
  427.     speed = (float)info->recv_data_len / diff_time;

  429.     return speed;
  430. }

  432. /* 接收服务器的响应数据 */
  433. int recv_response(http_t *info)
  434. {
  435.     int len = 0, total_len = info->len;

  437.     if(info->chunked_flag)
  438.         return recv_chunked_response(info);

  440.     if(-1 == read_data(info, total_len))
  441.         return -1;

  443.     return 0;
  444. }

  446. /* 清理操作 */
  447. void clean_up(http_t *info)
  448. {
  449.     if(info->in)
  450.         fclose(info->in);
  451.     if(-1 != info->sock)
  452.         close(info->sock);
  453.     if(info->save_file)
  454.         fclose(info->save_file);
  455.     if(info)
  456.         free(info);
  457. }

  459. /* 下载主函数 */
  460. int http_download(char *url, char *save_path)
  461. {
  462.     http_t *info = NULL;
  463.     char tmp[URI_MAX_LEN] = {0};

  465.     if(!url || !save_path)
  466.         return -1;

  468.     //初始化结构体
  469.     info = malloc(sizeof(http_t));
  470.     if(!info)
  471.     {
  472.         lprintf(MSG_ERROR, "malloc failed\n");
  473.         return -1;
  474.     }
  475.     memset(info, 0x0, sizeof(http_t));
  476.     info->sock = -1;
  477.     info->save_path = save_path;

  479.     // 解析url
  480.     if(-1 == parser_URL(url, info))
  481.         goto failed;

  483.     // 连接到server
  484.     if(-1 == connect_server(info))
  485.         goto failed;

  487.     // 发送http请求报文
  488.     if(-1 == send_request(info))
  489.         goto failed;

  491.     // 接收响应的头信息
  492.     info->in = fdopen(info->sock, "r");
  493.     if(!info->in)
  494.     {
  495.         lprintf(MSG_ERROR, "fdopen error\n");
  496.         goto failed;
  497.     }

  499.     // 解析头部
  500.     if(-1 == parse_http_header(info))
  501.         goto failed;

  503.     switch(info->status_code)
  504.     {
  505.         case HTTP_OK:
  506.             // 接收数据
  507.             lprintf(MSG_DEBUG, "recv data now\n");
  508.             info->start_recv_time = time(0);
  509.             if(-1 == recv_response(info))
  510.                 goto failed;

  512.             info->end_recv_time = time(0);
  513.             lprintf(MSG_INFO, "recv %d bytes\n", info->recv_data_len);
  514.             lprintf(MSG_INFO, "Average download speed: %.2fKB/s\n",
  515.                     calc_download_speed(info)/1000);
  516.             break;
  517.         case HTTP_REDIRECT:
  518.             // 重启本函数
  519.             lprintf(MSG_INFO, "redirect: %s\n", info->location);
  520.             strncpy(tmp, info->location, URI_MAX_LEN - 1);
  521.             clean_up(info);
  522.             return http_download(tmp, save_path);

  524.         case HTTP_NOT_FOUND:
  525.             // 退出
  526.             lprintf(MSG_ERROR, "Page not found\n");
  527.             goto failed;
  528.             break;

  530.         default:
  531.             lprintf(MSG_INFO, "Not supported http code %d\n", info->status_code);
  532.             goto failed;
  533.     }

  535.     clean_up(info);
  536.     return 0;
  537. failed:
  538.     clean_up(info);
  539.     return -1;
  540. }

  542. /****************************************************************************
  543. 测试用例:
  544. (1)chunked接收测试
  545. ./a.out "http://www.httpwatch.com/httpgallery/chunked/chunkedimage.aspx" test.aspx
  546. (2)重定向测试
  547. ./a.out "192.168.10.1/main.html" test.txt
  548. (3)错误输入测试
  549. ./a.out "32131233" test.txt
  550. (4)根目录输入测试
  551. ./a.out "" test.txt
  552. (5)端口号访问测试
  553. ./a.out "192.168.0.200:8000/FS_AC6V1.0BR_V15.03.4.12_multi_TD01.bin" test.txt
  554. ****************************************************************************/

  556. int main(int argc, char *argv[])
  557. {
  558.     if(argc < 3)
  559.         return -1;

  561.     http_download(argv[1], argv[2]);
  562.     return 0;
  563. }

原文路径：https://www.cnblogs.com/dong1/p/9510350.html

阅读(527) | 评论(0) | 转发(0) |
0

上一篇：驱动加载脚本

下一篇：获取Wi-Fi链接信号

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6