Annotation of embedtools/src/upd.c, revision 1.2
1.2 ! misho 1: /*************************************************************************
! 2: * (C) 2010 AITNET - Sofia/Bulgaria - <office@aitbg.com>
! 3: * by Michael Pounov <misho@aitbg.com>
! 4: *
! 5: * $Author: misho $
! 6: * $Id: upd.c,v 1.1.2.10 2011/06/08 09:15:32 misho Exp $
! 7: *
! 8: *************************************************************************/
! 9: #include "global.h"
! 10: #include "upd.h"
! 11:
! 12:
! 13: int Kill;
! 14:
! 15:
! 16: static inline int ChkImg(const char *csImg, char *psDir)
! 17: {
! 18: int res = 0;
! 19:
! 20: getcwd(psDir, MAXPATHLEN);
! 21: if (access(csImg, R_OK) == -1) {
! 22: printf("Error:: Unable to find new image %s #%d - %s\n",
! 23: csImg, errno, strerror(errno));
! 24: res = -1;
! 25: } else {
! 26: strlcat(psDir, "/", MAXPATHLEN);
! 27: strlcat(psDir, csImg, MAXPATHLEN);
! 28: }
! 29:
! 30: return res;
! 31: }
! 32:
! 33: // -------------------------------
! 34:
! 35: int Activate(const char *csImg)
! 36: {
! 37: char szDir[MAXPATHLEN];
! 38:
! 39: if (ChkImg(csImg, szDir) == -1)
! 40: return -1;
! 41:
! 42: VERB(3) printf("Activate procedure for %s\n", szDir);
! 43:
! 44: unlink(FIRMWARE_IMG);
! 45: if (symlink(szDir, FIRMWARE_IMG) == -1) {
! 46: printf("Error:: Unable to activate new image %s #%d - %s\n",
! 47: csImg, errno, strerror(errno));
! 48: return -2;
! 49: }
! 50:
! 51: syslog(LOG_NOTICE, "Activate new image %s", csImg);
! 52: VERB(1) printf("Activate new image %s\n", csImg);
! 53: return 0;
! 54: }
! 55:
! 56: int Install(const char *csImg, const char *psDir)
! 57: {
! 58: int src, dst, len;
! 59: u_char buf[BUFSIZ];
! 60: char szDir[MAXPATHLEN], szFile[MAXPATHLEN];
! 61: struct stat ss, ds;
! 62:
! 63: strlcpy(szFile, psDir, MAXPATHLEN);
! 64: strlcat(szFile, "/", MAXPATHLEN);
! 65: strlcat(szFile, csImg, MAXPATHLEN);
! 66: if (access(szFile, R_OK) == -1) {
! 67: printf("Error:: Unable to find new image %s #%d - %s\n",
! 68: csImg, errno, strerror(errno));
! 69: return -1;
! 70: } else {
! 71: memset(&ss, 0, sizeof ss);
! 72: if (stat(szFile, &ss) == -1) {
! 73: printf("Error:: Unable to find new image %s #%d - %s\n",
! 74: csImg, errno, strerror(errno));
! 75: return -1;
! 76: }
! 77: }
! 78:
! 79: getcwd(szDir, MAXPATHLEN);
! 80: VERB(3) printf("Install procedure from %s to %s\n", szFile, szDir);
! 81: strlcat(szDir, "/", MAXPATHLEN);
! 82: strlcat(szDir, csImg, MAXPATHLEN);
! 83: memset(&ds, 0, sizeof ds);
! 84: if (stat(szDir, &ds) == -1 && ENOENT != errno) {
! 85: printf("Error:: Unable to stat target #%d - %s\n",
! 86: errno, strerror(errno));
! 87: return -1;
! 88: }
! 89:
! 90: if (ss.st_dev == ds.st_dev && ss.st_ino == ds.st_ino) {
! 91: printf("Error:: Unable to install into self ...\n");
! 92: return -1;
! 93: }
! 94:
! 95: dst = open(szDir, O_WRONLY | O_CREAT | O_TRUNC, 0644);
! 96: if (dst == -1) {
! 97: printf("Error:: in create image %s #%d - %s\n",
! 98: szDir, errno, strerror(errno));
! 99: return -1;
! 100: }
! 101: src = open(szFile, O_RDONLY);
! 102: if (src == -1) {
! 103: printf("Error:: in open image %s #%d - %s\n",
! 104: szFile, errno, strerror(errno));
! 105: close(dst);
! 106: unlink(szDir);
! 107: return -1;
! 108: }
! 109:
! 110: while ((len = read(src, buf, BUFSIZ)) > 0)
! 111: if (write(dst, buf, len) == -1) {
! 112: printf("Error:: in write image #%d - %s\n",
! 113: errno, strerror(errno));
! 114: close(src);
! 115: close(dst);
! 116: unlink(szDir);
! 117:
! 118: len = -1;
! 119: break;
! 120: }
! 121:
! 122: close(src);
! 123: close(dst);
! 124:
! 125: if (!len) {
! 126: syslog(LOG_NOTICE, "Install image %s to %s", csImg, szDir);
! 127: VERB(1) printf("Install image %s to %s\n", csImg, szDir);
! 128: }
! 129: return len;
! 130: }
! 131:
! 132: int Rollback(const char *csImg)
! 133: {
! 134: int src, dst, len;
! 135: u_char buf[BUFSIZ];
! 136: char szDir[MAXPATHLEN], szFile[MAXPATHLEN];
! 137: struct stat ss, ds;
! 138:
! 139: getcwd(szFile, MAXPATHLEN);
! 140: strlcat(szFile, "/", MAXPATHLEN);
! 141: strlcat(szFile, FIRMWARE_BAK, MAXPATHLEN);
! 142: if (access(szFile, R_OK) == -1) {
! 143: printf("Error:: Unable to find backup image #%d - %s\n",
! 144: errno, strerror(errno));
! 145: return -1;
! 146: } else {
! 147: memset(&ss, 0, sizeof ss);
! 148: if (stat(szFile, &ss) == -1) {
! 149: printf("Error:: Unable to find backup image #%d - %s\n",
! 150: errno, strerror(errno));
! 151: return -1;
! 152: }
! 153: }
! 154:
! 155: getcwd(szDir, MAXPATHLEN);
! 156: strlcat(szDir, "/", MAXPATHLEN);
! 157: strlcat(szDir, csImg, MAXPATHLEN);
! 158: VERB(3) printf("Rollback procedure for image %s from backup!\n", csImg);
! 159: memset(&ds, 0, sizeof ds);
! 160: if (stat(szDir, &ds) == -1 && ENOENT != errno) {
! 161: printf("Error:: Unable to stat target #%d - %s\n",
! 162: errno, strerror(errno));
! 163: return -1;
! 164: }
! 165:
! 166: if (ss.st_dev == ds.st_dev && ss.st_ino == ds.st_ino) {
! 167: printf("Error:: Unable to rollback into self ...\n");
! 168: return -1;
! 169: }
! 170:
! 171: src = open(szFile, O_RDONLY);
! 172: if (src == -1) {
! 173: printf("Error:: in open backup %s #%d - %s\n",
! 174: szFile, errno, strerror(errno));
! 175: return -1;
! 176: }
! 177: dst = open(szDir, O_WRONLY | O_CREAT | O_TRUNC, 0644);
! 178: if (dst == -1) {
! 179: printf("Error:: in create image %s #%d - %s\n",
! 180: szDir, errno, strerror(errno));
! 181: close(src);
! 182: return -1;
! 183: }
! 184:
! 185: while ((len = read(src, buf, BUFSIZ)) > 0)
! 186: if (write(dst, buf, len) == -1) {
! 187: printf("Error:: in write image #%d - %s\n",
! 188: errno, strerror(errno));
! 189: close(dst);
! 190: close(src);
! 191: unlink(szDir);
! 192:
! 193: len = -1;
! 194: break;
! 195: }
! 196:
! 197: close(dst);
! 198: close(src);
! 199:
! 200: if (!len) {
! 201: syslog(LOG_NOTICE, "Rollback image %s to %s", csImg, szDir);
! 202: VERB(1) printf("Rollback image %s to %s\n", csImg, szDir);
! 203: }
! 204: return len;
! 205:
! 206: return 0;
! 207: }
! 208:
! 209: int tFTP(const char *csImg, const char *psDir)
! 210: {
! 211: int src, dst, len;
! 212: u_char buf[BUFSIZ];
! 213: char szDir[MAXPATHLEN], szFile[MAXPATHLEN];
! 214: struct stat ss, ds;
! 215:
! 216: if (ChkImg(csImg, szDir) == -1)
! 217: return -1;
! 218: else {
! 219: memset(&ss, 0, sizeof ss);
! 220: if (stat(szDir, &ss) == -1) {
! 221: printf("Error:: Unable to find image %s #%d - %s\n",
! 222: szDir, errno, strerror(errno));
! 223: return -1;
! 224: }
! 225: }
! 226:
! 227: VERB(3) printf("tFTP procedure for %s to %s\n", szDir, psDir);
! 228: strlcpy(szFile, psDir, MAXPATHLEN);
! 229: strlcat(szFile, "/", MAXPATHLEN);
! 230: strlcat(szFile, csImg, MAXPATHLEN);
! 231: memset(&ds, 0, sizeof ds);
! 232: if (stat(szFile, &ds) == -1 && ENOENT != errno) {
! 233: printf("Error:: Unable to stat target %s #%d - %s\n",
! 234: szFile, errno, strerror(errno));
! 235: return -1;
! 236: }
! 237:
! 238: if (ss.st_dev == ds.st_dev && ss.st_ino == ds.st_ino) {
! 239: printf("Error:: Unable to copy into self ...\n");
! 240: return -1;
! 241: }
! 242:
! 243: dst = open(szFile, O_WRONLY | O_CREAT | O_TRUNC, 0644);
! 244: if (dst == -1) {
! 245: printf("Error:: in create backup %s #%d - %s\n",
! 246: szFile, errno, strerror(errno));
! 247: return -1;
! 248: }
! 249: src = open(szDir, O_RDONLY);
! 250: if (src == -1) {
! 251: printf("Error:: in open image %s #%d - %s\n",
! 252: szDir, errno, strerror(errno));
! 253: close(dst);
! 254: unlink(szFile);
! 255: return -1;
! 256: }
! 257:
! 258: while ((len = read(src, buf, BUFSIZ)) > 0)
! 259: if (write(dst, buf, len) == -1) {
! 260: printf("Error:: in write backup #%d - %s\n",
! 261: errno, strerror(errno));
! 262: close(src);
! 263: close(dst);
! 264: unlink(szFile);
! 265:
! 266: len = -1;
! 267: break;
! 268: }
! 269:
! 270: close(src);
! 271: close(dst);
! 272:
! 273: if (!len) {
! 274: syslog(LOG_NOTICE, "Export tFTP image %s to %s", csImg, psDir);
! 275: VERB(1) printf("Export tFTP image %s to %s\n", csImg, psDir);
! 276: }
! 277: return len;
! 278: }
! 279:
! 280: int Backup(const char *csImg)
! 281: {
! 282: int src, dst, len;
! 283: u_char buf[BUFSIZ];
! 284: char szDir[MAXPATHLEN], szFile[MAXPATHLEN];
! 285:
! 286: if (ChkImg(csImg, szDir) == -1)
! 287: return -1;
! 288:
! 289: getcwd(szFile, MAXPATHLEN);
! 290: strlcat(szFile, "/", MAXPATHLEN);
! 291: strlcat(szFile, FIRMWARE_BAK, MAXPATHLEN);
! 292: VERB(3) printf("Backup procedure for %s\n", szDir);
! 293:
! 294: dst = open(szFile, O_WRONLY | O_CREAT | O_TRUNC, 0644);
! 295: if (dst == -1) {
! 296: printf("Error:: in create backup %s #%d - %s\n",
! 297: szFile, errno, strerror(errno));
! 298: return -1;
! 299: }
! 300: src = open(szDir, O_RDONLY);
! 301: if (src == -1) {
! 302: printf("Error:: in open image %s #%d - %s\n",
! 303: szDir, errno, strerror(errno));
! 304: close(dst);
! 305: unlink(szFile);
! 306: return -1;
! 307: }
! 308:
! 309: while ((len = read(src, buf, BUFSIZ)) > 0)
! 310: if (write(dst, buf, len) == -1) {
! 311: printf("Error:: in write backup #%d - %s\n",
! 312: errno, strerror(errno));
! 313: close(src);
! 314: close(dst);
! 315: unlink(szFile);
! 316:
! 317: len = -1;
! 318: break;
! 319: }
! 320:
! 321: close(src);
! 322: close(dst);
! 323:
! 324: if (!len) {
! 325: syslog(LOG_NOTICE, "Backup image %s", csImg);
! 326: VERB(1) printf("Backup image %s\n", csImg);
! 327: }
! 328: return len;
! 329: }
! 330:
! 331: int Clean(const char *csImg)
! 332: {
! 333: char szDir[MAXPATHLEN], szFile[MAXPATHLEN];
! 334:
! 335: if (ChkImg(csImg, szDir) == -1)
! 336: return -1;
! 337:
! 338: getcwd(szFile, MAXPATHLEN);
! 339: strlcat(szFile, "/", MAXPATHLEN);
! 340: strlcat(szFile, FIRMWARE_BAK, MAXPATHLEN);
! 341:
! 342: VERB(3) printf("Clean procedure for %s\n", szDir);
! 343:
! 344: if (unlink(szFile) == -1) {
! 345: printf("Error:: in clean backup #%d - %s\n", errno, strerror(errno));
! 346: return -1;
! 347: }
! 348:
! 349: syslog(LOG_NOTICE, "Clean backup for image %s", csImg);
! 350: VERB(1) printf("Clean backup for image %s\n", csImg);
! 351: return 0;
! 352: }
! 353:
! 354: // ----------------------------------
! 355:
! 356: static void Signal(int sig)
! 357: {
! 358: int stat;
! 359:
! 360: switch (sig) {
! 361: case SIGHUP:
! 362: VERB(5) printf("Info(5):: Signal arrived #%d\n", sig);
! 363: break;
! 364: case SIGCHLD:
! 365: while (waitpid(-1, &stat, WNOHANG) > 0);
! 366: break;
! 367: case SIGTERM:
! 368: Kill = 1;
! 369: VERB(5) printf("Info(5):: Signal arrived #%d\n", sig);
! 370: break;
! 371: }
! 372: }
! 373:
! 374: int Daemonize(struct sockaddr_in sin, const char *csTFTP)
! 375: {
! 376: int s, n = 1;
! 377: pid_t pid;
! 378: fd_set rfd;
! 379: u_short seq = 0xffff;
! 380: int clilen, len, f, retry;
! 381: struct sockaddr_in cli, rcv;
! 382: struct sigaction sa;
! 383: u_char buf[TFTP_BUF], *pos;
! 384: char szFName[MAX_STR];
! 385: struct tftphdr *tftp = (struct tftphdr*) buf;
! 386: struct timeval tv = { TFTP_TIMEOUT, 0 };
! 387:
! 388: VERB(3) printf("Daemonize procedure for %s:%d to %s\n",
! 389: inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), csTFTP);
! 390:
! 391: memset(&sa, 0, sizeof sa);
! 392: sigemptyset(&sa.sa_mask);
! 393: sa.sa_handler = Signal;
! 394: sigaction(SIGCHLD, &sa, NULL);
! 395: sigaction(SIGTERM, &sa, NULL);
! 396: sigaction(SIGHUP, &sa, NULL);
! 397:
! 398: s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
! 399: if (s == -1) {
! 400: printf("Error:: in create socket #%d - %s\n", errno, strerror(errno));
! 401: return -1;
! 402: }
! 403: if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &n, sizeof n) == -1) {
! 404: printf("Error:: in socket options #%d - %s\n", errno, strerror(errno));
! 405: close(s);
! 406: return -1;
! 407: }
! 408: if (bind(s, (struct sockaddr*) &sin, sizeof sin) == -1) {
! 409: printf("Error:: in bind #%d - %s\n", errno, strerror(errno));
! 410: close(s);
! 411: return -1;
! 412: }
! 413:
! 414: switch ((pid = fork())) {
! 415: case -1:
! 416: printf("Error:: in socket options #%d - %s\n", errno, strerror(errno));
! 417: close(s);
! 418: return -1;
! 419: case 0:
! 420: setsid();
! 421:
! 422: while (!Kill) {
! 423: FD_ZERO(&rfd);
! 424: FD_SET(s, &rfd);
! 425: if (select(s + 1, &rfd, NULL, NULL, NULL) == -1)
! 426: continue;
! 427:
! 428: memset(buf, 0, TFTP_BUF);
! 429: clilen = sizeof cli;
! 430: len = recvfrom(s, buf, TFTP_BUF, 0, (struct sockaddr*) &cli,
! 431: (socklen_t*) &clilen);
! 432: if (len == -1) {
! 433: VERB(5) printf("Error:: in recvfrom #%d - %s\n",
! 434: errno, strerror(errno));
! 435: continue;
! 436: }
! 437:
! 438: tftp = (struct tftphdr*) (pos = buf);
! 439: VERB(5) printf("Info(5):: Received packet from %s len %d with opcode=%hd\n",
! 440: inet_ntoa(cli.sin_addr), len, ntohs(tftp->th_opcode));
! 441: switch (ntohs(tftp->th_opcode)) {
! 442: case WRQ:
! 443: len -= 2;
! 444: pos += 2;
! 445: strlcpy(szFName, (char*) pos, MAX_STR);
! 446: VERB(5) printf("Info(5):: Get filename %s\n", szFName);
! 447: len -= strlen((char*) pos) + 1;
! 448: pos += strlen((char*) pos) + 1;
! 449: VERB(5) printf("Info(5):: Get mode %s len=%d\n", pos, len);
! 450: if (strncmp((char*) pos, "octet", len)) {
! 451: memset(buf, 0, TFTP_BUF);
! 452: tftp->th_opcode = htons(ERROR);
! 453: tftp->th_code = htons(EBADOP);
! 454: strncpy(tftp->th_data, "Error:: mode not supported", 27);
! 455: sendto(s, buf, 31, 0, (struct sockaddr*) &cli, sizeof cli);
! 456: continue;
! 457: }
! 458: VERB(2) printf("Info(2):: Receive file %s from %s\n",
! 459: szFName, inet_ntoa(cli.sin_addr));
! 460:
! 461: f = open(szFName, O_WRONLY | O_CREAT | O_EXCL, 0644);
! 462: if (f == -1) {
! 463: memset(buf, 0, TFTP_BUF);
! 464: tftp->th_opcode = htons(ERROR);
! 465: switch (errno) {
! 466: case EACCES:
! 467: case EPERM:
! 468: tftp->th_code = htons(EACCESS);
! 469: break;
! 470: case EEXIST:
! 471: tftp->th_code = htons(EEXISTS);
! 472: break;
! 473: default:
! 474: tftp->th_code = htons(ENOSPACE);
! 475: }
! 476: snprintf(tftp->th_data, STRSIZ, "Error:: in file %s",
! 477: strerror(errno));
! 478: sendto(s, buf, strlen(tftp->th_data) + 4, 0,
! 479: (struct sockaddr*) &cli, sizeof cli);
! 480: continue;
! 481: }
! 482:
! 483: memset(buf, 0, TFTP_BUF);
! 484: tftp->th_opcode = htons(ACK);
! 485: tftp->th_block = seq = 0;
! 486: sendto(s, tftp, 4, 0, (struct sockaddr*) &cli, sizeof cli);
! 487:
! 488: for (retry = TFTP_RETRY; retry;) {
! 489: FD_ZERO(&rfd);
! 490: FD_SET(s, &rfd);
! 491: if (select(s + 1, &rfd, NULL, NULL, &tv) < 1) {
! 492: retry--;
! 493: continue;
! 494: }
! 495: memset(buf, 0, TFTP_BUF);
! 496: clilen = sizeof sin;
! 497: if ((len = recvfrom(s, buf, TFTP_BUF, 0,
! 498: (struct sockaddr*) &rcv,
! 499: (socklen_t*) &clilen)) == -1) {
! 500: VERB(5) printf("Error:: in recvfrom #%d - %s\n",
! 501: errno, strerror(errno));
! 502: retry--;
! 503: continue;
! 504: } else
! 505: if (cli.sin_addr.s_addr != rcv.sin_addr.s_addr)
! 506: continue;
! 507:
! 508: VERB(5) printf("Info(5):: received opcode=%d block=%d seq=%d\n",
! 509: ntohs(tftp->th_opcode), ntohs(tftp->th_block), seq);
! 510: if (ERROR == ntohs(tftp->th_opcode)) {
! 511: syslog(LOG_ERR, "Error:: in tftp receiving #%d - %s",
! 512: tftp->th_code, tftp->th_data);
! 513: close(f);
! 514: unlink(szFName);
! 515: break;
! 516: }
! 517: if (DATA == ntohs(tftp->th_opcode) &&
! 518: ++seq == ntohs(tftp->th_block)) {
! 519: if (write(f, tftp->th_data, len - 4) == -1) {
! 520: syslog(LOG_ERR, "Error:: Can`t write to file %s\n",
! 521: szFName);
! 522: close(f);
! 523: unlink(szFName);
! 524: break;
! 525: }
! 526:
! 527: memset(buf, 0, TFTP_BUF);
! 528: tftp->th_opcode = htons(ACK);
! 529: tftp->th_block = htons(seq);
! 530: sendto(s, tftp, 4, 0, (struct sockaddr*) &rcv, sizeof rcv);
! 531: VERB(5) printf("Info(5):: Send ACK for %s block=%d\n",
! 532: inet_ntoa(cli.sin_addr), seq);
! 533:
! 534: if (SEGSIZE > len - 4) {
! 535: close(f);
! 536: syslog(LOG_INFO, "TFTP transfer complete to %s",
! 537: szFName);
! 538: break;
! 539: }
! 540: } else {
! 541: memset(buf, 0, TFTP_BUF);
! 542: tftp->th_opcode = htons(ERROR);
! 543: tftp->th_code = htons(EBADID);
! 544: snprintf(tftp->th_data, STRSIZ, "Error:: in transfer #%d",
! 545: seq);
! 546: sendto(s, buf, strlen(tftp->th_data) + 4, 0,
! 547: (struct sockaddr*) &cli, sizeof cli);
! 548: retry--;
! 549: }
! 550: }
! 551: if (!retry) {
! 552: close(f);
! 553: unlink(szFName);
! 554: syslog(LOG_ERR, "Error:: transfer aborted - timeout!");
! 555: }
! 556:
! 557: break;
! 558: case RRQ:
! 559: len -= 2;
! 560: pos += 2;
! 561: strlcpy(szFName, (char*) pos, MAX_STR);
! 562: VERB(5) printf("Info(5):: Get filename %s\n", szFName);
! 563: len -= strlen((char*) pos) + 1;
! 564: pos += strlen((char*) pos) + 1;
! 565: VERB(5) printf("Info(5):: Get mode %s len=%d\n", pos, len);
! 566: if (strncmp((char*) pos, "octet", len)) {
! 567: memset(buf, 0, TFTP_BUF);
! 568: tftp->th_opcode = htons(ERROR);
! 569: tftp->th_code = htons(EBADOP);
! 570: strncpy(tftp->th_data, "Error:: mode not supported", 27);
! 571: sendto(s, buf, 31, 0, (struct sockaddr*) &cli, sizeof cli);
! 572: continue;
! 573: }
! 574: VERB(2) printf("Info(2):: Send file %s to %s\n",
! 575: szFName, inet_ntoa(cli.sin_addr));
! 576:
! 577: f = open(szFName, O_RDONLY);
! 578: if (f == -1) {
! 579: memset(buf, 0, TFTP_BUF);
! 580: tftp->th_opcode = htons(ERROR);
! 581: switch (errno) {
! 582: case EACCES:
! 583: case EPERM:
! 584: tftp->th_code = htons(EACCESS);
! 585: break;
! 586: case ENOENT:
! 587: tftp->th_code = htons(ENOTFOUND);
! 588: break;
! 589: default:
! 590: tftp->th_code = htons(ENOSPACE);
! 591: }
! 592: snprintf(tftp->th_data, STRSIZ, "Error:: in file %s",
! 593: strerror(errno));
! 594: sendto(s, buf, strlen(tftp->th_data) + 4, 0,
! 595: (struct sockaddr*) &cli, sizeof cli);
! 596: continue;
! 597: } else
! 598: seq = 1;
! 599:
! 600: for (retry = TFTP_RETRY; retry;) {
! 601: tftp->th_opcode = htons(DATA);
! 602: tftp->th_block = htons(seq);
! 603: if ((len = read(f, tftp->th_data, SEGSIZE)) == -1) {
! 604: syslog(LOG_ERR, "Error:: Can`t read from file %s\n",
! 605: szFName);
! 606: close(f);
! 607: break;
! 608: } else
! 609: sendto(s, buf, len + 4, 0,
! 610: (struct sockaddr*) &cli, sizeof cli);
! 611:
! 612: FD_ZERO(&rfd);
! 613: FD_SET(s, &rfd);
! 614: if (select(s + 1, &rfd, NULL, NULL, &tv) < 1) {
! 615: retry--;
! 616: continue;
! 617: }
! 618: memset(buf, 0, TFTP_BUF);
! 619: clilen = sizeof sin;
! 620: if (recvfrom(s, buf, TFTP_BUF, 0, (struct sockaddr*) &rcv,
! 621: (socklen_t*) &clilen) == -1) {
! 622: VERB(5) printf("Error:: in recvfrom #%d - %s\n",
! 623: errno, strerror(errno));
! 624: retry--;
! 625: continue;
! 626: } else
! 627: if (cli.sin_addr.s_addr != rcv.sin_addr.s_addr)
! 628: continue;
! 629:
! 630: VERB(5) printf("Info(5):: received opcode=%d block=%d seq=%d\n",
! 631: ntohs(tftp->th_opcode), ntohs(tftp->th_block), seq);
! 632: if (ERROR == ntohs(tftp->th_opcode)) {
! 633: syslog(LOG_ERR, "Error:: in tftp sending #%d - %s",
! 634: tftp->th_code, tftp->th_data);
! 635: if (lseek(f, len * -1, SEEK_CUR) == -1) {
! 636: syslog(LOG_ERR, "Error:: revert sending #%d - %s",
! 637: errno, strerror(errno));
! 638: close(f);
! 639: break;
! 640: }
! 641: retry--;
! 642: continue;
! 643: }
! 644: if (ACK == ntohs(tftp->th_opcode) &&
! 645: seq == ntohs(tftp->th_block)) {
! 646: seq++;
! 647: if (SEGSIZE > len) {
! 648: close(f);
! 649: syslog(LOG_INFO, "TFTP transfer complete to %s",
! 650: szFName);
! 651: break;
! 652: }
! 653: } else {
! 654: memset(buf, 0, TFTP_BUF);
! 655: tftp->th_opcode = htons(ERROR);
! 656: tftp->th_code = htons(EBADID);
! 657: snprintf(tftp->th_data, STRSIZ, "Error:: in transfer #%d",
! 658: seq);
! 659: sendto(s, buf, strlen(tftp->th_data) + 4, 0,
! 660: (struct sockaddr*) &cli, sizeof cli);
! 661: retry--;
! 662: }
! 663: }
! 664: if (!retry) {
! 665: close(f);
! 666: syslog(LOG_ERR, "Error:: transfer aborted - timeout!");
! 667: }
! 668:
! 669: break;
! 670: case DATA:
! 671: if (seq == 0xffff)
! 672: VERB(5) printf("Error:: not specified operation!\n");
! 673: break;
! 674: }
! 675: }
! 676:
! 677: break;
! 678: }
! 679:
! 680:
! 681: close(s);
! 682: return 0;
! 683: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to upd.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedtools / src