int crc_stwr(void) { docrc = 1; return(dev_start()); }
int loop_socket_handle(int socket, int tt_ms) { unsigned char outhexbuf[ONE_TCP_MAX_LEN] = {0}; PRO *pro = (PRO*)malloc(sizeof(PRO)); memset(pro, 0, sizeof(PRO)); pro->payload = (unsigned char*)malloc(ONLINE_MAX_LEN); memset(pro->payload, 0, (ONLINE_MAX_LEN)); int ret = 0; int login_ok = 0; unsigned int sendseq = 0; int outinx = 0; int hexlen = 0; MACH_STAT stat = IDLE; while(1) { debug(LOG_NOTICE, "stat=%d,login_flag=%d,outinx=%d,last_cmd=%04x,last_recv_ret=%d,dev_work_status=%d\n", stat,login_ok,outinx,pro->hd.cmd,ret,dev_work_status); switch(stat) { case IDLE: //sleep_intp_s(5); //will block tcp recving break; case TO_LOGIN: memset(&pro->hd, 0, sizeof(PRO_HD)); memset(pro->payload, 0, (ONLINE_MAX_LEN)); send_login_info(socket, pro, sendseq++); break; case TO_DEVSTATUS: //recv_uart(); //send_dev_data(); if(glb_cfg.glb_sock != socket) glb_cfg.glb_sock = socket; // uart thread will write glb_sock directly. break; case TO_WORKSTATUS: memset(pro->payload, 0, (ONLINE_MAX_LEN)); if(dev_work_status == E_DEV_TAKEUP) { send_busy_info(socket, pro, dev_work_status, sendseq++); } else { send_status_info(socket, pro, dev_work_status, sendseq++); } stat = IDLE; break; case TO_RESPSTATUS: memset(pro->payload, 0, (ONLINE_MAX_LEN)); response_status_info(socket, pro, dev_work_status, sendseq++); stat = IDLE; break; case TO_HEART: memset(&pro->hd, 0, sizeof(PRO_HD)); send_heart_info(socket, &pro->hd, sendseq++); if(outinx++ > HEART_EXIT_COUNT) goto EXIT_ERR; else stat = IDLE; break; case TO_RESP: //for testing;all back pro->hd.stat = PRO_RSP; memset(outhexbuf, 0, sizeof(outhexbuf)); hexlen = 0; pro_pro2hexbuf(pro,outhexbuf,&hexlen); send(socket, outhexbuf, hexlen, sendseq++); debug(LOG_DEBUG, "Send Resp Len:%d\n",hexlen); stat = IDLE; break; case NET_DISCONN: goto EXIT_ERR; break; default: break; } //memset(pro, 0, sizeof(PRO)); //NOTE***: will init payload as NULL; this will cause crash!!! memset(&pro->hd, 0, sizeof(PRO_HD)); memset(pro->payload, 0, (ONLINE_MAX_LEN)); ret = socket_recv_tt(socket, pro, tt_ms); if(ret == 0) { // timeout if(!login_ok) { stat = TO_LOGIN; } else { stat = TO_HEART; } } else if(ret < 0) { // socket error goto EXIT_ERR; } else if( (ret != sizeof(PRO_HD)) && (ret != sizeof(PRO_HD)+pro->hd.len) ) { debug(LOG_NOTICE, "Recv Length %d Error!\n",ret); continue; } else { // handle data... switch(pro->hd.cmd) { case IDM_DEV_LOGIN: debug(LOG_NOTICE, "---< server back: login\n"); login_ok = 1; if(dev_work_status != E_DEV_TAKEUP) dev_work_status = E_DEV_ONLINE; stat = TO_DEVSTATUS; break; case IDM_DEV_HEART: debug(LOG_NOTICE, "---< server back: heart\n"); outinx = 0; break; case IDM_GETDEV: debug(LOG_NOTICE, "---< server cmd: get dev\n"); stat = TO_RESPSTATUS; break; /* for response testing */ case 0xfffe: debug(LOG_NOTICE, "---< server cmd: test response\n"); stat = TO_RESP; break; case IDM_TAKEUPDEV: case IDM_RELEASEDEV: case IDM_RESET: case IDM_DOSTART: case IDM_DOSTOP: case IDM_SETPARS: case IDM_DELPARS: if(0 == memcmp(taskid, pro->payload+32, 32)) { break; } else { if(dev_work_status == E_DEV_TAKEUP) { debug(LOG_WARNING, "---< server taskid is not correct!\n"); stat = TO_WORKSTATUS; continue; } else { /* Firstly takeup device */ break; } } default: debug(LOG_ERR, "==== Handle: Unknow Server CMD 0x%02x\n", pro->hd.cmd); continue; } switch(pro->hd.cmd) { /* handle at local */ case IDM_TAKEUPDEV: debug(LOG_NOTICE, "---< server cmd: takeup dev\n"); dev_work_status = E_DEV_TAKEUP; stat = TO_WORKSTATUS; memcpy(taskid, pro->payload+32, sizeof(taskid)); /* skip devid 32*/ break; case IDM_RELEASEDEV: debug(LOG_NOTICE, "---< server cmd: release dev\n"); dev_work_status = E_DEV_ONLINE; stat = TO_WORKSTATUS; memset(taskid, 0, sizeof(taskid)); break; /* send to uart */ case IDM_RESET: debug(LOG_NOTICE, "---< server cmd: reset dev\n"); dev_work_status = E_DEV_ONLINE; stat = TO_WORKSTATUS; /* stop and clear */ dev_reset(pro->payload, pro->hd.len); break; case IDM_DOSTART: debug(LOG_NOTICE, "---< server cmd: start dev\n"); glb_cfg.rsp_cmd_type = SVR_NEED_TASK_RET; glb_cfg.rsp_cmd_type |= SVR_NEED_TASK_PERCT; /* only send payload to uart */ ret = dev_start(pro->payload, pro->hd.len); debug(LOG_DEBUG, "---Send To Com ret %d\n",ret); break; case IDM_DOSTOP: debug(LOG_NOTICE, "---< server cmd: stop dev\n"); glb_cfg.rsp_cmd_type = SVR_NEED_TASK_RET; /* only send payload to uart */ ret = dev_stop(pro->payload, pro->hd.len); debug(LOG_DEBUG, "---Send To Com ret %d\n",ret); break; case IDM_SETPARS: debug(LOG_NOTICE, "---< server cmd: set params dev\n"); /* only send params to uart */ ret = dev_setpar(pro->payload+64+2, (pro->hd.len-66)>0?(pro->hd.len-66):0); debug(LOG_DEBUG, "---Send To Com ret %d\n",ret); break; case IDM_DELPARS: debug(LOG_NOTICE, "---< server cmd: del params\n"); /* only send payload to uart */ ret = dev_clrpar(pro->payload, pro->hd.len); debug(LOG_DEBUG, "---Send To Com ret %d\n",ret); break; } } continue; } /* end while(1) */ EXIT_ERR: debug(LOG_NOTICE, "<--- Socket recv out!\n"); glb_cfg.glb_sock = -1; glb_cfg.rsp_cmd_type = 0; if(socket > 0) close(socket); if(pro && pro->payload) { free(pro->payload); free(pro); } return -1; }
int cpio_stwr(void) { return(dev_start()); }
int append(void) { ARCHD *arcn; int res; FSUB *orgfrmt; int udev; off_t tlen; arcn = &archd; orgfrmt = frmt; /* * Do not allow an append operation if the actual archive is of a * different format than the user specified format. */ if (get_arc() < 0) return 1; if ((orgfrmt != NULL) && (orgfrmt != frmt)) { tty_warn(1, "Cannot mix current archive format %s with %s", frmt->name, orgfrmt->name); return 1; } /* * pass the format any options and start up format */ if (((*frmt->options)() < 0) || ((*frmt->st_rd)() < 0)) return 1; /* * if we only are adding members that are newer, we need to save the * mod times for all files we see. */ if (uflag && (ftime_start() < 0)) return 1; /* * some archive formats encode hard links by recording the device and * file serial number (inode) but copy the file anyway (multiple times) * to the archive. When we append, we run the risk that newly added * files may have the same device and inode numbers as those recorded * on the archive but during a previous run. If this happens, when the * archive is extracted we get INCORRECT hard links. We avoid this by * remapping the device numbers so that newly added files will never * use the same device number as one found on the archive. remapping * allows new members to safely have links among themselves. remapping * also avoids problems with file inode (serial number) truncations * when the inode number is larger than storage space in the archive * header. See the remap routines for more details. */ if ((udev = frmt->udev) && (dev_start() < 0)) return 1; /* * reading the archive may take a long time. If verbose tell the user */ if (vflag || Vflag) { (void)fprintf(listf, "%s: Reading archive to position at the end...", argv0); vfpart = 1; } /* * step through the archive until the format says it is done */ while (next_head(arcn) == 0) { /* * check if this file meets user specified options. */ if (sel_chk(arcn) != 0) { if (rd_skip(arcn->skip + arcn->pad) == 1) break; continue; } if (uflag) { /* * see if this is the newest version of this file has * already been seen, if so skip. */ if ((res = chk_ftime(arcn)) < 0) break; if (res > 0) { if (rd_skip(arcn->skip + arcn->pad) == 1) break; continue; } } /* * Store this device number. Device numbers seen during the * read phase of append will cause newly appended files with a * device number seen in the old part of the archive to be * remapped to an unused device number. */ if ((udev && (add_dev(arcn) < 0)) || (rd_skip(arcn->skip + arcn->pad) == 1)) break; } /* * done, finish up read and get the number of bytes to back up so we * can add new members. The format might have used the hard link table, * purge it. */ tlen = (*frmt->end_rd)(); lnk_end(); /* * try to position for write, if this fails quit. if any error occurs, * we will refuse to write */ if (appnd_start(tlen) < 0) return 1; /* * tell the user we are done reading. */ if ((vflag || Vflag) && vfpart) { (void)safe_print("done.\n", listf); vfpart = 0; } /* * go to the writing phase to add the new members */ res = wr_archive(arcn, 1); if (res == 1) { /* * wr_archive failed in some way, but before any files were * added. These are the only steps needed to cleanup (and * not truncate the archive). */ wr_fin(); (void)sigprocmask(SIG_BLOCK, &s_mask, (sigset_t *)NULL); ar_close(); } return res; }