/* REQ-S2LRD-PINTFC-API-BASIC-RNG-002 */ fsl_shw_return_t fsl_shw_get_random( fsl_shw_uco_t* user_ctx, uint32_t length, uint8_t* data) { fsl_shw_return_t ret = FSL_RETURN_ERROR_S; /* perform a sanity check / update uco */ ret = validate_uco(user_ctx); if (ret == FSL_RETURN_OK_S) { struct get_random_req* req = malloc(sizeof(*req)); if (req == NULL) { ret = FSL_RETURN_NO_RESOURCE_S; } else { init_req(&req->hdr, user_ctx); req->size = length; req->random = data; ret = send_req(SHW_USER_REQ_GET_RANDOM, &req->hdr, user_ctx); } } return ret; }
/* **************************************************************** * Filho: Espera receber novos pedidos * **************************************************************** */ void filho (void) { SERVTB *sp; DNS dns; for (EVER) { if (ioctl (udp_fd, I_DNS_WAIT_REQ, &dns) < 0) error ("*Erro no \"ioctl\" I_DNS_WAIT_REQ"); if (vflag) error ( "Recebendo pedido do endereço de \"%s\"", dns.d_host_nm ); for (sp = servtb; sp->s_addr != 0; sp++) { if (vflag) error ( "Consultando a \"%s\"", t_addr_to_str (sp->s_addr) ); send_req (sp, &dns); } } /* end for (EVER) */ } /* end filho */
fsl_shw_return_t fsl_shw_add_entropy( fsl_shw_uco_t* user_ctx, uint32_t length, uint8_t* data) { fsl_shw_return_t ret = FSL_RETURN_ERROR_S; /* perform a sanity check on the uco */ ret = validate_uco(user_ctx); if (ret == FSL_RETURN_OK_S) { struct add_entropy_req* req = malloc(sizeof(*req)); if (req == NULL) { ret = FSL_RETURN_NO_RESOURCE_S; } else { init_req(&req->hdr, user_ctx); req->size = length; req->entropy = data; ret = send_req(SHW_USER_REQ_ADD_ENTROPY, &req->hdr, user_ctx); } } return ret; }
int exec_req(int sockfd, struct sd_req *hdr, void *data, unsigned int *wlen, unsigned int *rlen) { int ret; struct sd_rsp *rsp = (struct sd_rsp *)hdr; if (send_req(sockfd, hdr, data, wlen)) return 1; ret = do_read(sockfd, rsp, sizeof(*rsp)); if (ret) { eprintf("failed to read a response: %m\n"); return 1; } if (*rlen > rsp->data_length) *rlen = rsp->data_length; if (*rlen) { ret = do_read(sockfd, data, *rlen); if (ret) { eprintf("failed to read the response data: %m\n"); return 1; } } return 0; }
void DNP_master_device::master_cb( tlm::tlm_generic_payload &arg_Req, sc_time& delay) { uint32_t addr = (uint32_t) arg_Req.get_address(); uint32_t len = (uint32_t) arg_Req.get_data_length(); uint8_t *data_ptr = (uint8_t *) arg_Req.get_data_ptr(); crt_trans_id ++ ; memset(recvd_data, 0, sizeof(recvd_data)); if (arg_Req.is_read()){ /* * Read command */ DPRINTF("R @ 0x%08x(%d) <%d>\n", addr, len, crt_trans_id); for(uint32_t i = 0; i < len; i+=4){ #ifdef DEBUG_DNP_MASTER uint32_t *p = (uint32_t *)recvd_data; #endif send_req(crt_trans_id, (addr + i), recvd_data, 4, false); wait(rsp_rcvd_ev); memcpy((data_ptr + i), (uint32_t *)recvd_data, 4); DPRINTF("R @ 0x%08x -- %08x \n", (addr + i), *p); } }else{ /* * Write command */ DPRINTF("W @ 0x%08x(%d) <%d>\n", addr, len, crt_trans_id); for (uint32_t i = 0; i < len; i+=4){ #ifdef DEBUG_DNP_MASTER uint32_t *p = (uint32_t *)(data_ptr + i); #endif DPRINTF("W @ 0x%08x -- %08x\n", (addr + i), *p); send_req(crt_trans_id, (addr + i), (data_ptr + i), 4, true); wait(rsp_rcvd_ev); } } arg_Req.set_response_status(tlm::TLM_OK_RESPONSE); }
int fb_io_device_master::cmd_read (uint32_t addr, uint8_t *data, uint8_t nbytes) { m_tr_nbytes = nbytes; send_req (m_crt_tid, addr, NULL, nbytes, 0); wait (ev_cmd_done); for (int i = 0; i < nbytes; i++) data[i] = ((unsigned char *) &m_tr_rdata)[i]; if (m_status != FB_MASTER_CMD_SUCCESS) return 0; return 1; }
static int send_req_and_recv_resp_sk(int fd, CriuReq *req, CriuResp **resp) { int ret = 0; if (send_req(fd, req) < 0) { ret = -ECOMM; goto exit; } again: *resp = recv_resp(fd); if (!*resp) { perror("Can't receive response"); ret = -ECOMM; goto exit; } if ((*resp)->type == CRIU_REQ_TYPE__NOTIFY) { if (notify) ret = notify((*resp)->notify->script, (*resp)->notify); ret = send_notify_ack(fd, ret); if (!ret) goto again; else goto exit; } if ((*resp)->type != req->type) { if ((*resp)->type == CRIU_REQ_TYPE__EMPTY && (*resp)->success == false) ret = -EINVAL; else { perror("Unexpected response type"); ret = -EBADMSG; } } exit: return ret; }
int exec_req(int sockfd, struct sd_req *hdr, void *data, bool (*need_retry)(uint32_t epoch), uint32_t epoch, uint32_t max_count) { int ret; struct sd_rsp *rsp = (struct sd_rsp *)hdr; unsigned int wlen, rlen; if (hdr->flags & SD_FLAG_CMD_WRITE) { wlen = hdr->data_length; if (hdr->flags & SD_FLAG_CMD_PIGGYBACK) rlen = hdr->data_length; else rlen = 0; } else { wlen = 0; rlen = hdr->data_length; } if (send_req(sockfd, hdr, data, wlen, need_retry, epoch, max_count)) return 1; ret = do_read(sockfd, rsp, sizeof(*rsp), need_retry, epoch, max_count); if (ret) { sd_err("failed to read a response"); return 1; } if (rlen > rsp->data_length) rlen = rsp->data_length; if (rlen) { ret = do_read(sockfd, data, rlen, need_retry, epoch, max_count); if (ret) { sd_err("failed to read the response data"); return 1; } } return 0; }
static void send_t(struct SerialPort *ser,int pipe_r,int pipe_w){ int res; pthread_t thread_rdpipe,thread_rdport; //fcntl((*ser).fd, F_SETFL, FNDELAY); //如果未读取到数据也立即返回。。 //fcntl((*ser).fd, F_SETFL, 0); res = pthread_create (&thread_rdpipe, NULL, handlerreadpipe, (void *)&pipe_r); if(res != 0){ perror("Thread thread_rdpipe create failed"); exit(EXIT_FAILURE); } res = pthread_create (&thread_rdport, NULL, handlerreadport, (void *)&(*ser).fd); if(res != 0){ perror("Thread thread_rdport create failed"); exit(EXIT_FAILURE); } while(1){ send_req((*ser).fd); printf("uart_fd:%d..\n",(*ser).fd); sleep(1); } }
static int send_notify_ack(int socket_fd, int ret) { int send_ret; CriuReq req = CRIU_REQ__INIT; req.type = CRIU_REQ_TYPE__NOTIFY; req.has_notify_success = true; req.notify_success = (ret == 0); send_ret = send_req(socket_fd, &req); /* * If we're failing the notification then report * back the original error code (and it will be * propagated back to user). * * If the notification was OK, then report the * result of acking it. */ return ret ? : send_ret; }
static int send_and_receive(struct ts_engine_client *client, uint8_t id, const void * const data, size_t len) { int ret; pthread_mutex_lock(&g_client_mutex); ret = send_req(client, id, data, len); if (ret < 0) { eng_dbg("send_req failed\n"); pthread_mutex_unlock(&g_client_mutex); return ERROR; } ret = receive_resp(client); if (ret < 0) { eng_dbg("receive_resp failed\n"); } pthread_mutex_unlock(&g_client_mutex); return ret; }
/*FUNC-************************************************************************/ int stop_daemon(void) { cmd_hdr cmd; response_buf resp_buf; int resp_buf_len; int ret; memset(&cmd, 0, sizeof(cmd)); cmd.type = CMD_REQUEST; cmd.cmd_id = CMD_STOP; resp_buf_len = sizeof(resp_buf); ret = send_req((char *)&cmd, sizeof(cmd), (char *)&resp_buf, &resp_buf_len); if (ret) { fprintf(stdout, "Daemon is down.\n"); goto EXIT; } else { if (resp_buf.o.stop.ack_status) { fprintf(stdout, "Daemon successfully stopped.\n"); } else { fprintf(stdout, "Unexpected error in stopping the daemon.\n"); } } ret = RET_OK; EXIT: return(ret); }
/*FUNC-************************************************************************/ int get_status(int mute) { cmd_hdr cmd; response_buf resp_buf; int resp_buf_len; int ret; memset(&cmd, 0, sizeof(cmd)); cmd.type = CMD_REQUEST; cmd.cmd_id = CMD_STATUS; resp_buf_len = sizeof(resp_buf); ret = send_req((char *)&cmd, sizeof(cmd), (char *)&resp_buf, &resp_buf_len); if (ret) { if (!mute) { fprintf(stdout, "Daemon is down.\n"); } goto EXIT; } else { if (!mute) { fprintf(stdout, "Daemon is running. PID: [%d]\n", resp_buf.o.status.pid); } } ret = RET_OK; EXIT: return(ret); }
int login_server(int id,char *hlrcode,char *hlrport, char *mgr_user, char *mgr_pswd, char *mgr_term) { int readlen,msglen,retn; loginreqptr=(struct login_req *)tcpbuf.data; strcpy(loginreqptr->username, mgr_user); strcpy(loginreqptr->userpswd, mgr_pswd); strcpy(loginreqptr->hlrcode, hlrcode); loginreqptr->hlrport = hlrport[0]; loginreqptr->termtype = mgr_term[0]; memcpy(loginreqptr->reserve, " ", 2); if(send_req(id,DECRYPT,TX_END,SRV_LOGIN,1,LOGINREQLEN)<0) { fprintf(logfp,"send_req(%d) failed[%d]\n",id,errno); return -2; } readlen = read_ack(connid, &tcpbuf); if(readlen != 0) { fprintf(logfp,"readnet(%d,8,%d)=%d failed!\n",id,msglen-8,readlen); return -6; } printf("RCV:%s~\n",(char *)&tcpbuf); loginackptr=(struct login_ack *)tcpbuf.data; retn=get_length(loginackptr->retn,4); encrypt_char=loginackptr->encrypt; memset(cipher,0x0,sizeof(cipher)); strncpy(cipher,loginackptr->cipher,8); printf("cipher===%s~\n",cipher); return retn; }
int main(int argc, char *argv[]) { CriuReq req = CRIU_REQ__INIT; CriuResp *resp = NULL; int fd, dir_fd; int ret = 0; struct sockaddr_un addr; socklen_t addr_len; if (argc != 3) { fprintf(stderr, "Usage: test-c criu-service.socket imgs_dir"); return -1; } /* * Open a directory, in which criu will * put images */ puts(argv[2]); dir_fd = open(argv[2], O_DIRECTORY); if (dir_fd == -1) { perror("Can't open imgs dir"); return -1; } /* * Set "DUMP" type of request. * Allocate CriuDumpReq. */ req.type = CRIU_REQ_TYPE__DUMP; req.opts = malloc(sizeof(CriuOpts)); if (!req.opts) { perror("Can't allocate memory for dump request"); return -1; } criu_opts__init(req.opts); /* * Set dump options. * Checkout more in protobuf/rpc.proto. */ req.opts->has_leave_running = true; req.opts->leave_running = true; req.opts->images_dir_fd = dir_fd; req.opts->has_log_level = true; req.opts->log_level = 4; /* * Connect to service socket */ fd = socket(AF_LOCAL, SOCK_SEQPACKET, 0); if (fd == -1) { perror("Can't create socket"); return -1; } memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_LOCAL; strcpy(addr.sun_path, argv[1]); addr_len = strlen(addr.sun_path) + sizeof(addr.sun_family); ret = connect(fd, (struct sockaddr *) &addr, addr_len); if (ret == -1) { perror("Cant connect to socket"); goto exit; } /* * Send request */ ret = send_req(fd, &req); if (ret == -1) { perror("Can't send request"); goto exit; } /* * Recv response */ resp = recv_resp(fd); if (!resp) { perror("Can't recv response"); ret = -1; goto exit; } if (resp->type != CRIU_REQ_TYPE__DUMP) { perror("Unexpected response type"); ret = -1; goto exit; } /* * Check response. */ if (resp->success) puts("Success"); else { puts("Fail"); ret = -1; goto exit; } if (resp->dump->has_restored && resp->dump->restored) puts("Restored"); exit: close(fd); close(dir_fd); if (resp) criu_resp__free_unpacked(resp, NULL); return ret; }
static int ui_android_read(UI *ui, UI_STRING *uis) { int ok = 0; int num = 0; const char *str; char **args; switch (UI_get_string_type(uis)) { case UIT_BOOLEAN: android_log(PRG_DEBUG, "called ui_android_read() output boolean %s", UI_get0_output_string(uis)); android_log(PRG_DEBUG, "called ui_android_read() action boolean %s", UI_get0_action_string(uis)); // UI_get_input_flags(uis) & UI_INPUT_FLAG_ECHO case UIT_PROMPT: str = UI_get0_output_string(uis); android_log(PRG_DEBUG, "called ui_android_read() output prompt %s", str); break; case UIT_VERIFY: str = UI_get0_output_string(uis); android_log(PRG_DEBUG, "called ui_android_read() verify output %s", str); break; default: return 1; break; } strlcat(ui_buf, "=X=", sizeof(ui_buf)); strlcat(ui_buf, str, sizeof(ui_buf)); process: if (send_req(ui_buf) < 0) { android_log(PRG_ERR, "send_req() failed"); goto out; } if (recv_cmd(&num, &args) < 0) { android_log(PRG_ERR, "recv_cmd() failed"); goto out; } if (num != 1) { android_log(PRG_ERR, "parameter number mismatch"); goto out; } android_log(PRG_DEBUG, "ui_android_read() cmd: %s %d", args[0], num); send_ack(num); UI_set_result(ui, uis, args[0]); ok = 1; out: if (num) free_cmd(num, args); ui_buf[0] = '\0'; return ok; }
static int gateway_forward_request(struct request *req) { int i, err_ret = SD_RES_SUCCESS, ret, local = -1; unsigned wlen; uint64_t oid = req->rq.obj.oid; int nr_to_send; struct write_info wi; const struct sd_op_template *op; struct sd_req hdr; const struct sd_node *target_nodes[SD_MAX_NODES]; sd_debug("%"PRIx64, oid); gateway_init_fwd_hdr(&hdr, &req->rq); op = get_sd_op(hdr.opcode); wlen = hdr.data_length; nr_to_send = init_target_nodes(req, oid, target_nodes); write_info_init(&wi, nr_to_send); if (nr_to_send == 0) { sd_debug("there is no living nodes"); return SD_RES_HALT; } for (i = 0; i < nr_to_send; i++) { struct sockfd *sfd; const struct node_id *nid; if (node_is_local(target_nodes[i])) { local = i; continue; } nid = &target_nodes[i]->nid; sfd = sockfd_cache_get(nid); if (!sfd) { err_ret = SD_RES_NETWORK_ERROR; break; } ret = send_req(sfd->fd, &hdr, req->data, wlen, sheep_need_retry, req->rq.epoch, MAX_RETRY_COUNT); if (ret) { sockfd_cache_del_node(nid); err_ret = SD_RES_NETWORK_ERROR; sd_debug("fail %d", ret); break; } write_info_advance(&wi, nid, sfd); } if (local != -1 && err_ret == SD_RES_SUCCESS) { assert(op); ret = sheep_do_op_work(op, req); if (ret != SD_RES_SUCCESS) { sd_err("fail to write local %"PRIx64", %s", oid, sd_strerror(ret)); err_ret = ret; } } sd_debug("nr_sent %d, err %x", wi.nr_sent, err_ret); if (wi.nr_sent > 0) { ret = wait_forward_request(&wi, req); if (ret != SD_RES_SUCCESS) err_ret = ret; } return err_ret; }
void data_store_csv::exchange_data() { double tm1 = get_time(); std::stringstream err; //get indices I need for the next epoch, and start receives std::unordered_set<int> indices; get_indices(indices, m_rank); std::vector<El::mpi::Request<DataType>> recv_req(indices.size()); m_my_minibatch_data.clear(); size_t jj = 0; for (auto data_id : indices) { m_my_minibatch_data[data_id].resize(m_vector_size); int owner = get_index_owner(data_id); if (owner >= m_np or owner < 0) { err << __FILE__ << " " << __LINE__ << " :: " << " ERROR: bad rank for owner in nb_recv; owner: " << owner << " data_id: " << data_id << " jj: " << jj+1 << " of " << indices.size(); throw lbann_exception(err.str()); } m_comm->nb_tagged_recv<DataType>(m_my_minibatch_data[data_id].data(), m_vector_size, owner, data_id, recv_req[jj++], m_comm->get_trainer_comm()); } //start sends to all processors std::vector<std::vector<El::mpi::Request<DataType>>> send_req(m_np); for (int p=0; p<m_np; p++) { get_my_indices(indices, p); send_req[p].resize(indices.size()); jj = 0; for (auto data_id : indices) { if (m_data.find(data_id) == m_data.end()) { err << __FILE__ << " " << __LINE__ << " :: " << " m_data.find(" << data_id << ") failed."; throw lbann_exception(err.str()); } if (m_data[data_id].size() != (size_t)m_vector_size) { err << __FILE__ << " " << __LINE__ << " :: " << " m_data[" << data_id << "].size = " << m_data[data_id].size() << " should be: " << m_vector_size << "; " << jj+1 << " of " << indices.size() << " m_reader->get_role: " << m_reader->get_role(); throw lbann_exception(err.str()); } m_comm->nb_tagged_send<DataType>(m_data[data_id].data(), m_vector_size, p, data_id, send_req[p][jj++], m_comm->get_trainer_comm()); } } //wait for sends to finish if (m_master) { for (size_t i=0; i<send_req.size(); i++) { m_comm->wait_all(send_req[i]); } } //wait for recvs to finish m_comm->wait_all(recv_req); if (m_master) { std::cerr << "TIME for data_store_csv::exchange_data(): " << get_time() - tm1 << "; role: " << m_reader->get_role() << "\n"; } }
int main(int argc,char **argv,char **envp) { long command_id; char hlr_code[8]; char phone_no[20]; char command_code[8]; char op_code[8]; char imsi_no[32]; char new_phone[20]; char new_imsi[32]; char business_status[8]; char mgr_user[20], mgr_pswd[20], mgr_term[10]; int ret; char inputstr[2048],ss[64]; int i,status,today; char srvip[32]; int srvport; char logfilename[256],logdir[256]; time_t t; struct tm *tv; char chhlr; int msglen,readlen,headlen,tcplen,bodylen; int transid; char order_fname[256],reply_fname[256],query_fname[256],cfginfo[1024],*p,*d; int line; FILE *cfgfp; char cfgstr[256]; procname=argv[0]; logfp=NULL; memset(inputstr,0x0,sizeof(inputstr)); for(i=0;i<argc;i++) { strcat(inputstr,argv[i]); strcat(inputstr," "); } if(GenDaemon()<0) { printf("GenDaemon() failed!\n"); exit(1); } signal(SIGTERM,LogOut); signal(SIGPIPE,SIG_IGN); signal(SIGCLD,SIG_IGN); signal(SIGINT,SIG_IGN); memset(hlrcode,0x0,sizeof(hlrcode)); memset(hlrport,0x0,sizeof(hlrport)); memset(logdir,0x0,sizeof(logdir)); while(--argc>0) { if(argv[argc][0]!='-') usage("Incorrect Parameter!"); printf("CMD:%c\n",argv[argc][1]); switch(argv[argc][1]) { case 'H': strncpy(hlrcode,argv[argc]+2,4); break; case 'N': strncpy(hlrport,argv[argc]+2,4); break; case 'L': strncpy(logdir,argv[argc]+2,240); break; case 'V': printf("\n\n version = %s\n\n",VERSION); exit(0); case 't': case 'T': test_flag = 1; break; default: usage("Unknow Parameter!"); break; } } printf("hlrcode===%s[%s]~\n",hlrcode,hlrport); if(strlen(hlrcode)!=3) usage("Incorrect parameter [hlrcode]!\n"); if(strlen(hlrport)!=1) usage("Incorrect parameter [hlrport]!\n"); if(strlen(logdir)<1) strcpy(logdir,getenv("LOGDIR")); if(testdir(logdir)) usage("Incorrect parameter [logdir]!"); time(&t); tv=localtime(&t); memset(logfilename,0x0,sizeof(logfilename)); sprintf(logfilename,"%s/erc%04d%02d%02d.%s.%s",logdir, tv->tm_year+1900,tv->tm_mon+1,tv->tm_mday,hlrcode,hlrport); logfp=fopen(logfilename,"a"); if(logfp==NULL) { printf("can't open %s for LOG!\n",logfilename); exit(1); } fprintf(logfp,"INIT %04d/%02d/%02d %02d:%02d:%02d\n", tv->tm_year+1900,tv->tm_mon+1,tv->tm_mday, tv->tm_hour,tv->tm_min,tv->tm_sec); fprintf(logfp,"%s[%d]\n",inputstr,argc); fflush(logfp); today=tv->tm_mday; /************ 获取连接配置信息 ********************/ if(get_hlr_cfg(hlrcode, atoi(hlrport), gsmip, &gsmport, gsmuser, gsmpswd, order_fname,reply_fname,query_fname, srvip, &commport, NULL, mgr_user, mgr_pswd, mgr_term) != 0) { fprintf(logfp,"get_cfg_filename(%s) failed!\n",hlrcode); fclose(logfp); exit(1); } /************ GET ORDER INFO ***********************/ cfgfp=fopen(order_fname,"r"); if(cfgfp==NULL) { fprintf(logfp,"Can't open %s for read[%d]\n",order_fname,errno); fclose(logfp); exit(1); } line=0; memset(cfginfo,0x0,sizeof(cfginfo)); while(fgets(cfginfo,sizeof(cfginfo),cfgfp)) { line++; if(cfginfo[0]=='#' || cfginfo[0]=='\r' || cfginfo[0]=='\n') { memset(cfginfo,0x0,sizeof(cfginfo)); continue; } if(strncmp(cfginfo,"OP",2) || (p=strchr(cfginfo,':'))==NULL) { fprintf(logfp,"Incorrect cfg_info[line=%d]\n",line); fclose(cfgfp); fclose(logfp); exit(1); } orderptr=(struct order_info *)malloc(sizeof(struct order_info)); memset(orderptr,0x0,sizeof(struct order_info)); orderptr->ordercode=atoi(cfginfo+2); strcpy(orderptr->orderinfo,rlspace(p+1)); if(strlen(orderptr->orderinfo)==0 || strlen(orderptr->orderinfo)>1000) { fprintf(logfp,"Incorrect cfg_info[line=%d]\n",line); fclose(cfgfp); fclose(logfp); exit(1); } ordertail=&orderhead; while(ordertail->next) { if(ordertail->next->ordercode==orderptr->ordercode) { fprintf(logfp,"ORDER_CODE[%d] is exists[line=%d]\n", orderptr->ordercode,line); fclose(logfp); fclose(cfgfp); exit(1); } ordertail=ordertail->next; } ordertail->next=orderptr; memset(cfginfo,0x0,sizeof(cfginfo)); } fclose(cfgfp); fprintf(logfp,"ORDER INFO:\n"); orderptr=orderhead.next; while(orderptr) { fprintf(logfp,"%06d = [%s]\n",orderptr->ordercode,orderptr->orderinfo); orderptr=orderptr->next; } fflush(logfp); /************ GET REPLY INFO ***********************/ cfgfp=fopen(reply_fname,"r"); if(cfgfp==NULL) { fprintf(logfp,"Can't open %s for read[%d]\n",reply_fname,errno); fclose(logfp); exit(1); } fprintf(logfp,"REPLY INFO:\n"); line=0; memset(cfginfo,0x0,sizeof(cfginfo)); while(fgets(cfginfo,sizeof(cfginfo),cfgfp)) { line++; if(cfginfo[0]=='#' || cfginfo[0]=='\r' || cfginfo[0]=='\n') { memset(cfginfo,0x0,sizeof(cfginfo)); continue; } fprintf(logfp,"%s",cfginfo); if(strncmp(cfginfo,"RETN:",5) || cfginfo[9]!=':') { fprintf(logfp,"Incorrect cfg_info[line=%d]\n",line); fclose(cfgfp); fclose(logfp); exit(1); } replyptr=(struct reply_info *)malloc(sizeof(struct reply_info)); memset(replyptr,0x0,sizeof(struct reply_info)); replyptr->replycode=atoi(cfginfo+5); p=cfginfo+10; d=replyptr->replyinfo; if(*p!='[' || strchr(p,']')==NULL) { fprintf(logfp,"Incorrect cfg_info[line=%d]\n",line); fclose(cfgfp); fclose(logfp); exit(1); } while(*(++p)!=']') { if(*p=='\\') { p++; switch(*p) { case 'r': *d='\r'; break; case 'n': *d='\n'; break; case 't': *d='\t'; break; default: *d=*p; } } else *d=*p; d++; } if(d==replyptr->replyinfo) { fprintf(logfp,"Incorrect cfg_info[line=%d]\n",line); fclose(cfgfp); fclose(logfp); exit(1); } replyptr->next=replyhead.next; replyhead.next=replyptr; memset(cfginfo,0x0,sizeof(cfginfo)); } fclose(cfgfp); fflush(logfp); /************ GET QUERY INFO ***********************/ ret=get_query_cfg(query_fname); if(ret) { fprintf(logfp,"get_query_cfg()===%d\n",ret); fclose(logfp); exit(1); } disp_query_cfg(); /************ INIT COMM_PORT ***********************/ connid=tcp_connect(srvip, commport); if(connid<0) { fprintf(logfp,"socket() failed[%d]\n",errno); fclose(logfp); exit(1); } if(login_server(connid, hlrcode, hlrport, mgr_user, mgr_pswd, mgr_term)) { fprintf(logfp,"login_server() failed!\n"); fclose(logfp); exit(1); } fprintf(logfp,"login_server(%s) success!\n",hlrcode); gsmid = tcp_connect(gsmip, gsmport); sndid=gsmid; rcvid=gsmid; /*** LOGIN HLR ***/ sleep(1); enter[0]='\r'; enter[1]=0x00; while(1) { RcvFrmFlag(); if(strstr(replystr+STATION,"<")) { break; } if(strstr(replystr+STATION,"USERCODE")) { cusnd(gsmuser,strlen(gsmuser)); cusnd(enter,1); continue; } if(strstr(replystr+STATION,"PASSWORD")) { cusnd(gsmpswd,strlen(gsmpswd)); cusnd(enter,1); continue; } cusnd(enter,1); } fprintf(logfp,"LOGIN HLR,SUCCESS![%ld]\n",time(NULL)); fflush(logfp); /************** GET AN ORDER AND DEAL ********************/ waitnum=0; transid=2; cmdreqptr=(struct cmd_data_req *)tcpbuf.data; cmdreqptr->type=ONLY_GET; yy_time.rec_time = time(NULL); strcpy(yy_time.hlrcode, hlrcode); strcpy(yy_time.hlrport, hlrport); while(1) { int data_flag = 0; gettimeofday(&t1, NULL); if(send_req(connid,DECRYPT,TX_END,GETORDER,transid++,CMDREQLEN)<0) { fprintf(logfp,"send_req(%d) failed[%d]\n",connid,errno); break; } readlen = read_ack(connid, &tcpbuf); if(readlen != 0) { fprintf(logfp,"readnet(%d,8,%d)=%d failed!\n",connid,msglen-8,readlen); break; } gettimeofday(&t2, NULL); cmdackptr=(struct cmd_data_ack *)tcpbuf.data; data_flag = (get_length(cmdackptr->retn,4) == 0001); if(data_flag){ yy_time.rows ++; yy_time.tm4get += time_diff1(t1, t2); } printf("RCV:%s~\n",(char *)&tcpbuf); ret=exec_cmd(); gettimeofday(&t1, NULL); if(data_flag){ yy_time.tm4exc += time_diff1(t2, t1); } printf("EXEC_CMD===========%d\n",ret); if(ret<0) { fprintf(logfp,"exec_cmd() failed!\n"); break; } time(&t); yy_time_log(t); tv=localtime(&t); if(today!=tv->tm_mday) { fclose(logfp); memset(logfilename,0x0,sizeof(logfilename)); sprintf(logfilename,"%s/erc%04d%02d%02d.%s.%s",logdir, tv->tm_year+1900,tv->tm_mon+1,tv->tm_mday,hlrcode,hlrport); logfp=fopen(logfilename,"a"); if(logfp==NULL) { printf("can't open %s for LOG!\n",logfilename); exit(1); } today=tv->tm_mday; } fflush(logfp); } fclose(logfp); close(connid); return 0; }
void bench(std::string cmd){ int total = (int)ds->size(); int finished = 0; int num_sent = 0; printf("========== %s ==========\n", cmd.c_str()); std::map<std::string, Data *>::iterator it; it = ds->begin(); double stime = millitime(); while(1){ while(!free_links->empty()){ if(num_sent == total){ break; } num_sent ++; Link *link = free_links->back(); free_links->pop_back(); send_req(link, cmd, it->second); it ++; } const Fdevents::events_t *events; events = fdes->wait(50); if(events == NULL){ log_error("events.wait error: %s", strerror(errno)); break; } for(int i=0; i<(int)events->size(); i++){ const Fdevent *fde = events->at(i); Link *link = (Link *)fde->data.ptr; int len = link->read(); if(len <= 0){ log_error("fd: %d, read: %d, delete link", link->fd(), len); exit(0); } const std::vector<Bytes> *resp = link->recv(); if(resp == NULL){ log_error("error"); break; }else if(resp->empty()){ continue; }else{ if(resp->at(0) != "ok"){ log_error("bad response: %s", resp->at(0).String().c_str()); exit(0); } free_links->push_back(link); finished ++; if(finished == total){ double etime = millitime(); double ts = (stime == etime)? 1 : (etime - stime); double speed = total / ts; printf("qps: %d, time: %.3f s\n", (int)speed, ts); return; } } } } }
/* * Open a TFTP connection on a random local port (our transaction ID). * Send the request, wait for first data block and send the first ACK. */ static int tftp_open (DWORD server, const char *fname) { int retry; WORD port = 69; #if defined(USE_BSD_API) struct servent *sp = getservbyname ("tftp", "udp"); if (sp) port = intel16 ((WORD)sp->s_port); #endif currblock = 0UL; blocksize = 0; for (retry = 0; retry < tftp_retry; retry++) { WORD our_tid; /* our transaction ID (local port) */ if (tftp_lport && tftp_lport < TFTP_PORT_LOW) outsnl (_LANG("tftp: Illegal local port.")); if (tftp_lport >= TFTP_PORT_LOW) our_tid = tftp_lport; else our_tid = Random (TFTP_PORT_LOW, TFTP_PORT_HIGH); /* Try to open a TFTP connection to the server */ if (!udp_open(&sock->udp, our_tid, server, port, NULL)) { TRACE (("tftp: %s\n", sockerr(sock))); return (0); } sock->udp.locflags |= LF_NOCLOSE; /* don't close socket on timeout */ /* Send the file request block, and then wait for the first data * block. If there is no response to the query, retry it with * another transaction ID (local port), so that all old packets get * discarded automatically. */ send_req (RRQ, fname); /* This hack makes it work because the response is sent back on * a source-port different from port 69; i.e. the server TID * uses a random port. Force the response packet to match a passive * socket in udp_handler(). */ sock->udp.hisaddr = 0; ibuflen = recv_packet (1); if (ibuflen >= 0) { blocksize = ibuflen; isopen = TRUE; send_ack (1); return (1); } /* If an error (except timeout) occurred, retries are useless */ if (tftp_errno == ERR_ERR || tftp_errno == ERR_UNKNOWN) break; } return (0); }
int forward_write_obj_req(struct request *req) { int i, fd, ret, pollret; unsigned wlen; char name[128]; struct sd_obj_req hdr = *(struct sd_obj_req *)&req->rq; struct sd_obj_rsp *rsp = (struct sd_obj_rsp *)&req->rp; struct sd_vnode *v; uint64_t oid = hdr.oid; int nr_copies; struct pollfd pfds[SD_MAX_REDUNDANCY]; int nr_fds, local = 0; dprintf("%"PRIx64"\n", oid); nr_fds = 0; memset(pfds, 0, sizeof(pfds)); for (i = 0; i < ARRAY_SIZE(pfds); i++) pfds[i].fd = -1; hdr.flags |= SD_FLAG_CMD_IO_LOCAL; wlen = hdr.data_length; nr_copies = get_nr_copies(req->vnodes); for (i = 0; i < nr_copies; i++) { v = oid_to_vnode(req->vnodes, oid, i); addr_to_str(name, sizeof(name), v->addr, 0); if (vnode_is_local(v)) { local = 1; continue; } fd = get_sheep_fd(v->addr, v->port, v->node_idx, hdr.epoch); if (fd < 0) { eprintf("failed to connect to %s:%"PRIu32"\n", name, v->port); ret = SD_RES_NETWORK_ERROR; goto out; } ret = send_req(fd, (struct sd_req *)&hdr, req->data, &wlen); if (ret) { /* network errors */ del_sheep_fd(fd); ret = SD_RES_NETWORK_ERROR; dprintf("fail %"PRIu32"\n", ret); goto out; } pfds[nr_fds].fd = fd; pfds[nr_fds].events = POLLIN; nr_fds++; } if (local) { ret = do_local_io(req, hdr.epoch); rsp->result = ret; if (nr_fds == 0) { eprintf("exit %"PRIu32"\n", ret); goto out; } if (rsp->result != SD_RES_SUCCESS) { eprintf("fail %"PRIu32"\n", ret); goto out; } } ret = SD_RES_SUCCESS; again: pollret = poll(pfds, nr_fds, DEFAULT_SOCKET_TIMEOUT * 1000); if (pollret < 0) { if (errno == EINTR) goto again; ret = SD_RES_EIO; } else if (pollret == 0) { /* poll time out */ eprintf("timeout\n"); for (i = 0; i < nr_fds; i++) del_sheep_fd(pfds[i].fd); ret = SD_RES_NETWORK_ERROR; goto out; } for (i = 0; i < nr_fds; i++) { if (pfds[i].fd < 0) break; if (pfds[i].revents & POLLERR || pfds[i].revents & POLLHUP || pfds[i].revents & POLLNVAL) { del_sheep_fd(pfds[i].fd); ret = SD_RES_NETWORK_ERROR; break; } if (!(pfds[i].revents & POLLIN)) continue; if (do_read(pfds[i].fd, rsp, sizeof(*rsp))) { eprintf("failed to read a response: %m\n"); del_sheep_fd(pfds[i].fd); ret = SD_RES_NETWORK_ERROR; break; } if (rsp->result != SD_RES_SUCCESS) { eprintf("fail %"PRIu32"\n", rsp->result); ret = rsp->result; } break; } if (i < nr_fds) { nr_fds--; memmove(pfds + i, pfds + i + 1, sizeof(*pfds) * (nr_fds - i)); } dprintf("%"PRIx64" %"PRIu32"\n", oid, nr_fds); if (nr_fds > 0) { goto again; } out: return ret; }
int show_whitelist_ip(void) { cmd_hdr *cmd; get_wl_ip_key_obj *req; get_wl_ip_key_obj next; get_wl_ip_acl_obj *wl_obj; src_dest_acl_obj *acl_obj; time_t cur_time; double delta_time; char buf[1024]; char *pbuf = buf; char src_ip[15]; char dst_ip[15]; char acl_id[15]; int secs_left; int i; int ctr = 1; int buf_len; int more = TRUE; int is_first = TRUE; int ret; memset(&next, 0, sizeof(next)); while (more) { cmd = (cmd_hdr *)pbuf; memset(cmd, 0, sizeof(cmd_hdr)); cmd->type = CMD_REQUEST; cmd->cmd_id = CMD_GET_WHITELIST_IP; cmd++; req = (get_wl_ip_key_obj *)cmd; *req = next; req++; buf_len = sizeof(buf); ret = send_req((char *)pbuf, ((char *)req - buf), (char *)buf, &buf_len); if (ret) { fprintf(stdout, "Daemon is down.\n"); break; } cmd = (cmd_hdr *)buf; if ((cmd->type != CMD_RESPONSE) || (cmd->cmd_id != CMD_GET_WHITELIST_IP)) { fprintf(stdout, " Unexpected response. Skipping.\n"); break; } cmd++; wl_obj = (get_wl_ip_acl_obj *)cmd; if (is_first) { fprintf(stdout, "Whitelisted Source-Destination IP Pair\n"); fprintf(stdout, "======================================\n"); fprintf(stdout, "ID SourceIP DestinationIP Seconds Left Age\n\n"); if (!wl_obj->n_acl) { fprintf(stdout, " No whitelisted source-destination IPs.\n"); break; } is_first = FALSE; } if (!wl_obj->n_acl) { break; } cur_time = time(NULL); acl_obj = (src_dest_acl_obj *)(wl_obj + 1); for (i = 0; i < wl_obj->n_acl; i++, acl_obj++, ctr++) { snprintf(src_ip, sizeof(src_ip), "%d.%d.%d.%d", (acl_obj->src >> 24) & 0xFF, (acl_obj->src >> 16) & 0xFF, (acl_obj->src >> 8) & 0xFF, acl_obj->src & 0xFF); snprintf(dst_ip, sizeof(dst_ip), "%d.%d.%d.%d", (acl_obj->dst >> 24) & 0xFF, (acl_obj->dst >> 16) & 0xFF, (acl_obj->dst >> 8) & 0xFF, acl_obj->dst & 0xFF); snprintf(acl_id, sizeof(acl_id), "[%d]", ctr); delta_time = difftime(cur_time, (time_t)acl_obj->created_at); secs_left = acl_obj->age - (int)delta_time; fprintf(stdout, "%-5s %-16s %-16s %-5d %lu\n", acl_id, src_ip, dst_ip, secs_left, acl_obj->age); next.src = acl_obj->src; next.dst = acl_obj->dst; } // more = FALSE; } fprintf(stdout, "\n"); ret = RET_OK; return(ret); }
static int gateway_forward_request(struct request *req, bool all_node) { int i, err_ret = SD_RES_SUCCESS, ret, local = -1; unsigned wlen; uint64_t oid = req->rq.obj.oid; int nr_to_send; struct write_info wi; struct sd_op_template *op; struct sd_req hdr; struct sd_node *target_nodes[SD_MAX_COPIES]; dprintf("%"PRIx64"\n", oid); gateway_init_fwd_hdr(&hdr, &req->rq); op = get_sd_op(hdr.opcode); write_info_init(&wi); wlen = hdr.data_length; nr_to_send = init_target_nodes(req, all_node, oid, target_nodes); for (i = 0; i < nr_to_send; i++) { struct sockfd *sfd; struct node_id *nid; if (node_is_local(target_nodes[i])) { local = i; continue; } nid = &target_nodes[i]->nid; sfd = sheep_get_sockfd(nid); if (!sfd) { err_ret = SD_RES_NETWORK_ERROR; break; } ret = send_req(sfd->fd, &hdr, req->data, &wlen); if (ret) { sheep_del_sockfd(nid, sfd); err_ret = SD_RES_NETWORK_ERROR; dprintf("fail %d\n", ret); break; } write_info_advance(&wi, nid, sfd); } if (local != -1 && err_ret == SD_RES_SUCCESS) { assert(op); ret = sheep_do_op_work(op, req); if (ret != SD_RES_SUCCESS) { eprintf("fail to write local %"PRIx32"\n", ret); err_ret = ret; } } dprintf("nr_sent %d, err %x\n", wi.nr_sent, err_ret); if (wi.nr_sent > 0) { ret = wait_forward_request(&wi, req); if (ret != SD_RES_SUCCESS) err_ret = ret; } return err_ret; }
int del_whitelist_ip(void) { cmd_hdr *cmd; del_wl_ip_key_obj *key; in_addr_t addr; char buf[1024]; char *pbuf = buf; int buf_len; int ret; if ((!opt_all) && !(strlen(acl_src_ip))) { fprintf(stdout, "Source IP or All option not specified.\n"); ret = RET_INVALID_PARAM; goto EXIT; } cmd = (cmd_hdr *)pbuf; memset(cmd, 0, sizeof(cmd_hdr)); cmd->type = CMD_REQUEST; cmd->cmd_id = CMD_DEL_WHITELIST_IP; cmd++; key = (del_wl_ip_key_obj *)cmd; memset(key, 0, sizeof(get_wl_ip_key_obj)); if (strlen(acl_src_ip)) { addr = inet_addr(acl_src_ip); if (addr < 0) { fprintf(stdout, "Invalid source IP: [%s]\n", acl_src_ip); ret = RET_INVALID_PARAM; goto EXIT; } key->src = ntohl(*((unsigned int *)&addr)); if (strlen(acl_dst_ip)) { addr = inet_addr(acl_dst_ip); if (addr < 0) { fprintf(stdout, "Invalid destination IP: [%s]\n", acl_dst_ip); ret = RET_INVALID_PARAM; goto EXIT; } key->dst = ntohl(*((unsigned int *)&addr)); } } key++; buf_len = sizeof(buf); ret = send_req((char *)pbuf, ((char *)key - buf), (char *)buf, &buf_len); if (ret) { fprintf(stdout, "Daemon is down.\n"); goto EXIT; } cmd = (cmd_hdr *)buf; if ((cmd->type != CMD_RESPONSE) || (cmd->cmd_id != CMD_DEL_WHITELIST_IP)) { fprintf(stdout, " Unexpected response. Skipping.\n"); ret = RET_INVALID_PARAM; goto EXIT; } cmd++; key = (del_wl_ip_key_obj *)cmd; switch (key->status) { case RET_OK: if (strlen(acl_src_ip)) { fprintf(stdout, "Source-destination whitelist deleted!\n"); } else { fprintf(stdout, "Deleted ALL whitelisted source-destination pairs.\n"); } break; case RET_DATA_NOT_FOUND: fprintf(stdout, "Source-destination NOT FOUND!\n"); break; default: fprintf(stdout, "Failed to delete source-destination whitelist!\n"); break; } ret = RET_OK; EXIT: return(ret); }
int main(int argc,char **argv,char **envp) { long command_id; char hlr_code[8]; char phone_no[20]; char command_code[8]; char op_code[8]; char imsi_no[32]; char new_phone[20]; char new_imsi[32]; char business_status[8]; struct timeval tt1, tt2; int ret; char inputstr[2048],ss[64]; int i,status,today; char srvip[32]; int srvport; char dbuser[32],dbpswd[32],dbname[32],tname[64]; char logfilename[256],logdir[256]; time_t t; struct tm *tv; char chhlr; int msglen,readlen,headlen,tcplen,bodylen; int transid; char order_fname[256],reply_fname[256],query_fname[256],cfginfo[1024],*p,*d; int line; int ordercode, etm; FILE *cfgfp; char cfgstr[256]; char mgr_user[20], mgr_pswd[20], mgr_term[10]; procname=argv[0]; logfp=NULL; memset(inputstr,0x0,sizeof(inputstr)); for(i=0;i<argc;i++) { strcat(inputstr,argv[i]); strcat(inputstr," "); } if(GenDaemon()<0) { printf("GenDaemon() failed!\n"); exit(1); } signal(SIGTERM,LogOut); signal(SIGPIPE,SIG_IGN); signal(SIGCLD,SIG_IGN); signal(SIGINT,SIG_IGN); memset(hlrcode,0x0,sizeof(hlrcode)); memset(hlrport,0x0,sizeof(hlrport)); memset(dbuser,0x0,sizeof(dbuser)); memset(dbpswd,0x0,sizeof(dbpswd)); memset(dbname,0x0,sizeof(dbname)); memset(logdir,0x0,sizeof(logdir)); while(--argc>0) { if(argv[argc][0]!='-') usage("Incorrect Parameter!"); printf("CMD:%c\n",argv[argc][1]); switch(argv[argc][1]) { case 'H': strncpy(hlrcode,argv[argc]+2,4); break; case 'N': strncpy(hlrport,argv[argc]+2,4); break; case 'U': strncpy(dbuser,argv[argc]+2,30); break; case 'P': strncpy(dbpswd,argv[argc]+2,30); break; case 'S': strncpy(dbname,argv[argc]+2,30); break; case 'L': strncpy(logdir,argv[argc]+2,240); break; case 'V': printf("\n\n version = %s\n\n",VERSION); exit(0); default: usage("Unknow Parameter!"); break; } } printf("hlrcode===%s[%s]~\n",hlrcode,hlrport); if(strlen(hlrcode)!=3) usage("Incorrect parameter [hlrcode]!\n"); if(strlen(hlrport)!=1) usage("Incorrect parameter [hlrport]!\n"); if(strlen(logdir)<1) strcpy(logdir,getenv("LOGDIR")); if(testdir(logdir)) usage("Incorrect parameter [logdir]!"); time(&t); tv=localtime(&t); memset(logfilename,0x0,sizeof(logfilename)); sprintf(logfilename,"%s/%s%04d%02d%02d.%s.%s",logdir, port_type, tv->tm_year+1900,tv->tm_mon+1,tv->tm_mday,hlrcode,hlrport); logfp=fopen(logfilename,"a"); if(logfp==NULL) { printf("can't open %s for LOG!\n",logfilename); exit(1); } fprintf(logfp,"INIT %04d/%02d/%02d %02d:%02d:%02d\n", tv->tm_year+1900,tv->tm_mon+1,tv->tm_mday, tv->tm_hour,tv->tm_min,tv->tm_sec); fprintf(logfp,"%s[%d]\n",inputstr,argc); fflush(logfp); today=tv->tm_mday; /************ 获取连接配置信息 ********************/ if(get_hlr_cfg(hlrcode, atoi(hlrport), gsmip, &gsmport, gsmuser, gsmpswd, order_fname,reply_fname,query_fname, srvip, &commport, NULL, mgr_user, mgr_pswd, mgr_term) != 0) { fprintf(logfp,"get_cfg_filename(%s) failed!\n",hlrcode); fclose(logfp); exit(1); } /************ GET ORDER INFO ***********************/ cfgfp=fopen(order_fname,"r"); if(cfgfp==NULL) { fprintf(logfp,"Can't open %s for read[%d]\n",order_fname,errno); fclose(logfp); exit(1); } line=0; memset(cfginfo,0x0,sizeof(cfginfo)); while(fgets(cfginfo,sizeof(cfginfo),cfgfp)) { line++; if(cfginfo[0]=='#' || cfginfo[0]=='\r' || cfginfo[0]=='\n') { memset(cfginfo,0x0,sizeof(cfginfo)); continue; } if(strncmp(cfginfo,"OP",2) || (p=strchr(cfginfo,':'))==NULL) { fprintf(logfp,"Incorrect cfg_info[line=%d]\n",line); fclose(cfgfp); fclose(logfp); exit(1); } orderptr=(struct order_info *)malloc(sizeof(struct order_info)); memset(orderptr,0x0,sizeof(struct order_info)); orderptr->ordercode=atoi(cfginfo+2); strcpy(orderptr->orderinfo,rlspace(p+1)); if(strlen(orderptr->orderinfo)==0 || strlen(orderptr->orderinfo)>1000) { fprintf(logfp,"Incorrect cfg_info[line=%d]\n",line); fclose(cfgfp); fclose(logfp); exit(1); } ordertail=&orderhead; while(ordertail->next) { if(ordertail->next->ordercode==orderptr->ordercode) { fprintf(logfp,"ORDER_CODE[%d] is exists[line=%d]\n", orderptr->ordercode,line); fclose(logfp); fclose(cfgfp); exit(1); } ordertail=ordertail->next; } ordertail->next=orderptr; memset(cfginfo,0x0,sizeof(cfginfo)); } fclose(cfgfp); /*fprintf(logfp,"ORDER INFO:\n"); orderptr=orderhead.next; while(orderptr) { fprintf(logfp,"%06d = [%s]\n",orderptr->ordercode,orderptr->orderinfo); orderptr=orderptr->next; } fflush(logfp);*/ /************ GET REPLY INFO ***********************/ cfgfp=fopen(reply_fname,"r"); if(cfgfp==NULL) { fprintf(logfp,"Can't open %s for read[%d]\n",reply_fname,errno); fclose(logfp); exit(1); } fprintf(logfp,"REPLY INFO:\n"); line=0; memset(cfginfo,0x0,sizeof(cfginfo)); while(fgets(cfginfo,sizeof(cfginfo),cfgfp)) { line++; if(cfginfo[0]=='#' || cfginfo[0]=='\r' || cfginfo[0]=='\n') { memset(cfginfo,0x0,sizeof(cfginfo)); continue; } /*fprintf(logfp,"%s",cfginfo); */ if(strncmp(cfginfo,"RETN:",5) || cfginfo[9]!=':') { fprintf(logfp,"Incorrect cfg_info[line=%d]\n",line); fclose(cfgfp); fclose(logfp); exit(1); } replyptr=(struct reply_info *)malloc(sizeof(struct reply_info)); memset(replyptr,0x0,sizeof(struct reply_info)); replyptr->replycode=atoi(cfginfo+5); p=cfginfo+10; d=replyptr->replyinfo; if(*p!='[' || strchr(p,']')==NULL) { fprintf(logfp,"Incorrect cfg_info[line=%d]\n",line); fclose(cfgfp); fclose(logfp); exit(1); } while(*(++p)!=']') { if(*p=='\\') { p++; switch(*p) { case 'r': *d='\r'; break; case 'n': *d='\n'; break; case 't': *d='\t'; break; default: *d=*p; } } else *d=*p; d++; } if(d==replyptr->replyinfo) { fprintf(logfp,"Incorrect cfg_info[line=%d]\n",line); fclose(cfgfp); fclose(logfp); exit(1); } replyptr->next=replyhead.next; replyhead.next=replyptr; memset(cfginfo,0x0,sizeof(cfginfo)); } fclose(cfgfp); fflush(logfp); /************ GET QUERY INFO ***********************/ ret=get_query_cfg(query_fname); if(ret) { fprintf(logfp,"get_query_cfg()===%d\n",ret); fclose(logfp); exit(1); } /*disp_query_cfg(); */ connid = tcp_connect(srvip, commport); if(connid < 0) { fprintf(logfp,"Incorrect IPADDR in mcfghead[%s]\n",srvip); fclose(logfp); exit(1); } memset(dbuser,0x0,sizeof(dbuser)); memset(dbpswd,0x0,sizeof(dbpswd)); memset(tname,0x0,sizeof(tname)); if(login_server(connid,hlrcode,hlrport, mgr_user, mgr_pswd, mgr_term)) { fprintf(logfp,"login_server() failed!\n"); fclose(logfp); exit(1); } fprintf(logfp,"login_server(%s) success!\n",hlrcode); /*** CONNECT TO HLR ** */ gsmid = tcp_connect(gsmip, gsmport); if(gsmid < 0){ fprintf(logfp, "connect(%s:%d) failed, errno:%d\n", gsmip, gsmport, errno); fclose(logfp); exit(1); } sndid=gsmid; rcvid=gsmid; /*** LOGIN HLR ***/ sprintf(ss, "%s\r\n", gsmuser); ret = sndcmd(sndid, "\nENTER USERNAME < \08 ", ss, strlen(ss), "\nENTER PASSWORD < \08 ", replystr, sizeof(replystr)); if(ret <= 0){ fprintf(logfp, "sndcmd username failed, return:%d\n", ret); fclose(logfp); return 2; } sprintf(ss, "%s\r\n", gsmpswd); ret = sndcmd(sndid, "\nENTER PASSWORD < \08 ", ss, strlen(ss), "\nMAIN LEVEL COMMAND <___>", replystr, sizeof(replystr)); if(ret <= 0){ fprintf(logfp, "sndcmd password failed, return:%d\n", ret); fclose(logfp); return 3; } fprintf(logfp,"LOGIN HLR,SUCCESS![%ld]\n",time(NULL)); fflush(logfp); /*if(1) exit(0); */ /************** GET AN ORDER AND DEAL ********************/ waitnum=0; transid=2; cmdreqptr=(struct cmd_data_req *)tcpbuf.data; cmdreqptr->type=ONLY_GET; while(1) { if(send_req(connid,DECRYPT,TX_END,GETORDER,transid++,CMDREQLEN)<0) { fprintf(logfp,"send_req(%d) failed[%d]\n",connid,errno); break; } readlen=readnet(connid,(char *)&tcpbuf,8); if(readlen!=8) { fprintf(logfp,"readnet(%d,0,8)=%d failed\n",connid,readlen); break; } if(strncmp(tcpbuf.flag,MSGFLAG,4)) { tcpbuf.msglen[0]=0; fprintf(logfp,"MSGFLAG is incorrect [%s]!\n",tcpbuf.flag); break; } msglen=get_length(tcpbuf.msglen,4); if(msglen<32) { fprintf(logfp,"MSGLEN is incorrect[%04d]\n",msglen); break; } readlen=readnet(connid,(char *)&tcpbuf+8,msglen-8); if(readlen!=msglen-8) { fprintf(logfp,"readnet(%d,8,%d)=%d failed!\n",connid,msglen-8,readlen); break; } printf("RCV:%s~\n",(char *)&tcpbuf); ordercode = 0; etm = 0; ret = exec_cmd( &ordercode, &etm); fprintf(logfp, "EXEC_CMD===========%d ordercode=%04d tm=%dms\n",ret, ordercode, etm); if(ret<0) { fprintf(logfp,"exec_cmd() failed!\n"); break; } time(&t); tv=localtime(&t); if(today!=tv->tm_mday) { fclose(logfp); memset(logfilename,0x0,sizeof(logfilename)); sprintf(logfilename,"%s/%s%04d%02d%02d.%s.%s",logdir, port_type, tv->tm_year+1900,tv->tm_mon+1,tv->tm_mday,hlrcode,hlrport); logfp=fopen(logfilename,"a"); if(logfp==NULL) { printf("can't open %s for LOG!\n",logfilename); exit(1); } today=tv->tm_mday; } fflush(logfp); } fclose(logfp); close(connid); return 0; }
/* **************************************************************** * Domain name resolver * **************************************************************** */ void main (int argc, const char *argv[]) { int opt; #if (0) /*******************************************************/ SERVTB *sp; int index; #endif /*******************************************************/ INADDR server_addr; T_BIND bind; /* * Pequena inicialização */ error_msg_to_log++; /* * Verifica se é SUPERUSUÁRIO */ if (geteuid () != 0) error ("$O usuário efetivo não é SUPERUSUÁRIO"); /* * Analisa as opções * * Sintaxe: * port_daemon [-v] <port_server_addr> ... */ while ((opt = getopt (argc, argv, "v")) != EOF) { switch (opt) { case 'v': /* Verbose */ vflag++; break; default: /* Erro */ putc ('\n', stderr); help (); } /* end switch */ } /* end while */ argv += optind; argc -= optind; #if (0) /*******************************************************/ if (argc == 0) help (); #endif /*******************************************************/ /* * Abre os "endpoint"s */ if ((udp_fd = t_open (udp_dev, O_RDWR, (T_INFO *)NULL)) < 0) error ("$*Não consegui abrir \"%s\"", udp_dev); /* * Obtém a porta local */ server_addr.a_port = PMAP_PORT; server_addr.a_addr = 0; bind.addr.len = sizeof (INADDR); bind.addr.maxlen = sizeof (INADDR); bind.addr.buf = &server_addr; if (t_bind (udp_fd, &bind, &bind) < 0) error ("$*Não consegui dar \"t_bind\" UDP"); send_req (); receive_answer (); #if (0) /*******************************************************/ /* * Cria um filho para enviar os pedidos de DNS. * O pai le os datagramas de resposta. */ if ((pidfilho = thread ()) < 0) error ("$*Não consegui criar um novo processo"); if (pidfilho > 0) pai (); else filho (); /* Não retorna */ #endif /*******************************************************/ } /* end port_mapper */