/* 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 */
