static void *read_thread(void *data) { struct vidsrc_st *st = data; while (st->run) { AVPacket pkt; av_init_packet(&pkt); if (av_read_frame(st->ic, &pkt) < 0) { sys_msleep(1000); av_seek_frame(st->ic, -1, 0, 0); continue; } if (pkt.stream_index != st->sindex) goto out; handle_packet(st, &pkt); /* simulate framerate */ sys_msleep(1000/st->fps); out: #if LIBAVCODEC_VERSION_INT >= ((57<<16)+(12<<8)+100) av_packet_unref(&pkt); #else av_free_packet(&pkt); #endif } return NULL; }
static void *read_thread(void *data) { struct vidsrc_st *st = data; while (st->run) { AVPacket pkt; av_init_packet(&pkt); if (av_read_frame(st->ic, &pkt) < 0) { sys_msleep(1000); av_seek_frame(st->ic, -1, 0, 0); continue; } if (pkt.stream_index != st->sindex) goto out; handle_packet(st, &pkt); /* simulate framerate */ sys_msleep(1000/st->fps); out: av_free_packet(&pkt); } return NULL; }
static void *tx_thread(void *arg) { struct audio *a = arg; struct autx *tx = &a->tx; unsigned i; /* Enable Real-time mode for this thread, if available */ if (a->cfg.txmode == AUDIO_MODE_THREAD_REALTIME) (void)realtime_enable(true, 1); while (a->tx.u.thr.run) { for (i=0; i<16; i++) { if (aubuf_cur_size(tx->aubuf) < tx->psize) break; poll_aubuf_tx(a); } sys_msleep(5); } return NULL; }
static void *play_thread(void *arg) { uint64_t now, ts = tmr_jiffies(); struct ausrc_st *st = arg; int16_t *sampv; sampv = mem_alloc(st->sampc * 2, NULL); if (!sampv) return NULL; while (st->run) { sys_msleep(4); now = tmr_jiffies(); if (ts > now) continue; aubuf_read_samp(st->aubuf, sampv, st->sampc); st->rh(sampv, st->sampc, st->arg); ts += st->ptime; } mem_deref(sampv); info("aufile: player thread exited\n"); return NULL; }
static void *read_thread(void *arg) { struct vidsrc_st *st = arg; uint64_t ts = 0; while (st->run) { uint64_t now; sys_msleep(2); now = tmr_jiffies(); if (!ts) ts = now; if (ts > now) continue; process(st); ts += 1000/st->prm.fps; } return NULL; }
void sys_threadpool_destroy(sys_threadpool *pool) { size_t i; if (!pool) return; pool->shutdown = true; sys_threadpool_wait_all(pool, UINT32_MAX); sys_msleep(10); sys_tls_free_key(pool->worker_key); for (i = 0; i < pool->workers.count; ++i) sys_thread_destroy(((sys_worker *)rt_array_get(&pool->workers, i))->thread); rt_array_release(&pool->workers); rt_array_release(&pool->active_tasks); rt_queue_release(&pool->task_queue); sys_cond_var_destroy(pool->task_notify); sys_mutex_destroy(pool->task_mutex); free(pool); }
static void ping_thread(void *arg) { int s; int timeout = PING_RCV_TIMEO; ip_addr_t ping_target; LWIP_UNUSED_ARG(arg); if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) { return; } lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); while (1) { ping_target = PING_TARGET; if (ping_send(s, &ping_target) == ERR_OK) { LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); ip_addr_debug_print(PING_DEBUG, &ping_target); LWIP_DEBUGF( PING_DEBUG, ("\n")); ping_time = sys_now(); ping_recv(s); } else { LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); ip_addr_debug_print(PING_DEBUG, &ping_target); LWIP_DEBUGF( PING_DEBUG, (" - error\n")); } sys_msleep(PING_DELAY); } }
/** * SNTP thread */ static void sntp_thread(void *arg) { LWIP_UNUSED_ARG(arg); while(1) { sntp_request(); sys_msleep(SNTP_UPDATE_DELAY); } }
static void ausrc_destructor(void *arg) { struct ausrc_st *st = arg; struct session *sess = st->sess; warning("DESTRUCT ausrc\n"); sess->run_src = false; sys_msleep(20); mem_deref(st->sampv); }
/** * SNTP thread */ static void sntp_thread(void *arg) { LWIP_UNUSED_ARG(arg); while (1) { dns_gethostbyname(SNTP_SERVER_NAME, &SNTPaddr, sntp_server_found, NULL); vTaskSuspend(NULL); sntp_request(); sys_msleep(SNTP_UPDATE_DELAY); } }
static void *read_thread(void *data) { struct vidsrc_st *st = data; uint64_t now, ts = tmr_jiffies(); while (st->run) { AVPacket pkt; int ret; sys_msleep(4); now = tmr_jiffies(); if (ts > now) continue; av_init_packet(&pkt); ret = av_read_frame(st->ic, &pkt); if (ret < 0) { debug("avformat: rewind stream (ret=%d)\n", ret); sys_msleep(1000); av_seek_frame(st->ic, -1, 0, 0); continue; } if (pkt.stream_index != st->sindex) goto out; handle_packet(st, &pkt); ts += (uint64_t) 1000 * pkt.duration * av_q2d(st->time_base); out: #if LIBAVCODEC_VERSION_INT >= ((57<<16)+(12<<8)+100) av_packet_unref(&pkt); #else av_free_packet(&pkt); #endif } return NULL; }
static void auplay_destructor(void *arg) { struct auplay_st *st = arg; struct session *sess = st->sess; warning("DESTRUCT auplay\n"); sess->run_play = false; sys_msleep(20); mem_deref(st->sampv); mem_deref(sess->dstmix); }
int HLR2::_exec(const char *url, const char *payload, unsigned short timeout, pugi::xml_document& doc, std::string& headers) { const short maxTry = 3; short retry = 0; if (!url || !*url) { LOG_ERROR("%s::%s: Invalid URL!", __class__, __func__); return -1; } while (maxTry >= ++retry) { short status = _hc.httpPost(url, payload, "text/xml", timeout); LOG_INFO("%s::%s: url: %s, payload: %s, timeout: %d, status: %d, headers: %s, body: %s", __class__, __func__, url, payload, timeout, status, _hc.getResponseHeaders(), _hc.getResponseBody()); if (200 != status && 307 != status) { return -1; } headers = _hc.getResponseHeaders(); std::string body = _hc.getResponseBody(); if (!doc.load(body.c_str())) { LOG_ERROR("%s::%s: Malformed XML response!: %s", __class__, __func__, body.c_str()); return -1; } pugi::xml_node result = doc.find_node(_isResult); int resultCode = atoi(result.child("ResultCode").child_value()); switch (resultCode) { case 0: case 3016: case 3810: //-- success, exit... return 0; case 5004: //-- invalid session, retry... LOG_INFO("%s::%s: Will retry: %d", __class__, __func__, retry); break; default: LOG_ERROR("%s::%s: ResultCode: %s, ResultDesc: %s", __class__, __func__, result.child("ResultCode").child_value(), result.child("ResultDesc").child_value()); return -1; } //-- wait for a while... sys_msleep(1000); } return -1; }
static void timeout_thread(void *arg) { int i; for (i = 0; i < TIMERS; i++) { diag_printf("Adding timer #%d\n", i); timers[i] = timeout_fn; intervals[i] = (i+1)*1000; sys_timeout(intervals[i], timers[i], (void *)i); } sys_msleep(0); diag_printf("Done\n"); }
/* Close a PPP connection and release the descriptor. * Any outstanding packets in the queues are dropped. * Return 0 on success, an error code on failure. */ int pppClose(int pd) { PPPControl *pc = &pppControl[pd]; int st = 0; /* Disconnect */ pc->kill_link = !0; pppMainWakeup(pd); if(!pc->linkStatusCB) { while(st >= 0 && lcp_phase[pd] != PHASE_DEAD) { sys_msleep(500); break; } } return st; }
static void *tx_thread(void *arg) { struct audio *a = arg; /* Enable Real-time mode for this thread, if available */ if (a->cfg.txmode == AUDIO_MODE_THREAD_REALTIME) (void)realtime_enable(true, 1); while (a->tx.u.thr.run) { poll_aubuf_tx(a); sys_msleep(5); } return NULL; }
/** * RTP send thread */ static void rtp_send_thread(void *arg) { int sock; struct sockaddr_in local; struct sockaddr_in to; u32_t rtp_stream_address; LWIP_UNUSED_ARG(arg); /* initialize RTP stream address */ rtp_stream_address = RTP_STREAM_ADDRESS; /* if we got a valid RTP stream address... */ if (rtp_stream_address != 0) { /* create new socket */ sock = socket(AF_INET, SOCK_DGRAM, 0); if (sock >= 0) { /* prepare local address */ memset(&local, 0, sizeof(local)); local.sin_family = AF_INET; local.sin_port = PP_HTONS(INADDR_ANY); local.sin_addr.s_addr = PP_HTONL(INADDR_ANY); /* bind to local address */ if (bind(sock, (struct sockaddr *)&local, sizeof(local)) == 0) { /* prepare RTP stream address */ memset(&to, 0, sizeof(to)); to.sin_family = AF_INET; to.sin_port = PP_HTONS(RTP_STREAM_PORT); to.sin_addr.s_addr = rtp_stream_address; /* send RTP packets */ memset(rtp_send_packet, 0, sizeof(rtp_send_packet)); while (1) { rtp_send_packets( sock, &to); sys_msleep(RTP_SEND_DELAY); } } /* close the socket */ closesocket(sock); } } }
void* default_unli_parser (void* arg) { void* retr = NULL; std::vector<std::string> list; std::string pattern = std::string(Config::getLocalProcessedDir()) + std::string("*.csv"); std::vector<default_unli_t> default_unlis; LOG_INFO("%s: Started.", __func__); LOG_INFO("%s: processing %s files.", __func__, pattern.c_str()); while (! IS_SHUTDOWN()) { glob(list, pattern); //LOG_DEBUG("%s: got %d files.", __func__, list.size()); for (size_t i=0; i<list.size(); ++i) { std::string &src = list[i]; std::string dest = Config::getLocalCompletedDir() + basename(src); load_default_unli(default_unlis, src); LOG_INFO("%s: got %d items from %s.", __func__, default_unlis.size(), src.c_str()); if (0 != mv(src, dest)) { LOG_ERROR("%s: Unable to move '%s' to '%s'", __func__, src.c_str(), dest.c_str()); continue; } for (size_t j=0; j<default_unlis.size(); ++j) { default_unli_t& default_unli = default_unlis[j]; if (0 != c2q_enqueue(Global::getDefaultUnliQ(), (void*) &default_unli, sizeof(default_unli_t))) { LOG_ERROR("%s: Unable to insert to default_unli queue: msisdn: %s, mnc: %s, mcc: %s, sgsn_ip: %s, date: %s, filename: %s", __func__ , default_unli.msisdn, default_unli.mnc, default_unli.mcc , default_unli.sgsn_ip, default_unli.date, default_unli.filename); } } } //-- sleep for a while sys_msleep(1000); } LOG_INFO("%s: Terminated.", __func__); return retr; }
int MQTTYield(MQTTClient* c, int timeout_ms) { int rc = SUCCESS; Timer timer; TimerInit(&timer); #if defined(MQTT_TASK) FreeRTOS_MutexLock(&c->mutex); #endif TimerCountdownMS(&timer, timeout_ms); //printf("."); rc = cycle(c, &timer); #if defined(MQTT_TASK) FreeRTOS_MutexUnlock(&c->mutex); #endif sys_msleep(1); return rc; }
static void *read_thread(void *arg) { struct vidsrc_st *st = arg; uint64_t ts = tmr_jiffies(); while (st->run) { if (tmr_jiffies() < ts) { sys_msleep(4); continue; } st->frameh(st->frame, st->arg); ts += (1000/st->fps); } return NULL; }
static void ping_host_thread(void *arg) { int s,i=0; int timeout = PING_RCV_TIMEO; ip_addr_t ping_target; char *host = (char *)arg; //LWIP_UNUSED_ARG(arg); if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) { return; } lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); while (1) { //ping_target = PING_TARGET; if (i>4) break; i++; (ip4_addr_set_u32(&ping_target, ipaddr_addr(host))); if (ping_send(s, &ping_target) == ERR_OK) { //LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); //ip_addr_debug_print(PING_DEBUG, &ping_target); //LWIP_DEBUGF( PING_DEBUG, ("\n")); rt_kprintf("ping: send "); ip_addr_debug_print1(&ping_target); rt_kprintf("\n"); ping_time = sys_now(); ping_recv(s); } else { //LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); //ip_addr_debug_print(PING_DEBUG, &ping_target); //LWIP_DEBUGF( PING_DEBUG, (" - error\n")); rt_kprintf("ping: send "); ip_addr_debug_print1(&ping_target); rt_kprintf(" - error\n"); } sys_msleep(PING_DELAY); } }
static void ping_host(char * host) { int s,i=0; int timeout = PING_RCV_TIMEO; ip_addr_t ping_target; if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) { return; } lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); while (1) { if (i>4) break; i++; //ping_target = netif_default->gw; //IP4_ADDR(&ping_target,210,82,5,1); (ip4_addr_set_u32(&ping_target, ipaddr_addr(host))); if (ping_send(s, &ping_target) == ERR_OK) { //LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); rt_kprintf("ping: send "); ip_addr_debug_print1(&ping_target); rt_kprintf("\n"); ping_time = sys_now(); ping_recv(s); } else { //LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); rt_kprintf("ping: send "); ip_addr_debug_print1(&ping_target); rt_kprintf(" - error\n"); //LWIP_DEBUGF( PING_DEBUG, (" - error\n")); } sys_msleep(PING_DELAY); } }
static void *play_thread(void *arg) { uint64_t now, ts = tmr_jiffies(); struct ausrc_st *st = arg; int16_t *sampv; sampv = mem_alloc(st->sampc * 2, NULL); if (!sampv) return NULL; while (st->run) { sys_msleep(4); now = tmr_jiffies(); if (ts > now) continue; #if 1 if (now > ts + 100) { debug("aufile: cpu lagging behind (%llu ms)\n", now - ts); } #endif aubuf_read_samp(st->aubuf, sampv, st->sampc); st->rh(sampv, st->sampc, st->arg); ts += st->ptime; } mem_deref(sampv); info("aufile: player thread exited\n"); return NULL; }
static void *play_thread(void *arg) { uint64_t now, ts = tmr_jiffies(); struct ausrc_st *st = arg; void *sampv; size_t num_bytes = st->sampc * st->sampsz; sampv = mem_alloc(num_bytes, NULL); if (!sampv) return NULL; while (st->run) { sys_msleep(4); now = tmr_jiffies(); if (ts > now) continue; #if 1 if (now > ts + 100) { debug("rst: cpu lagging behind (%u ms)\n", now - ts); } #endif aubuf_read(st->aubuf, sampv, num_bytes); st->rh(sampv, st->sampc, st->arg); ts += st->ptime; } mem_deref(sampv); return NULL; }
/** * This is the main system call function. It takes an interrupt stack frame * and decodes which interrupt number generated the system call. This number * is used to decode which system call was called. * * The stack frame is used to both pass and receive information from the * system call. * ECX: On completion of the system call ecx is populated with the return * value * EAX: Contains the system call number * EBX: Contains the ptr to the first of the parameters * * @param frame Ptr to a handler_stack_frame struture * @return SUCCESS on success or FAILURE if something goes wrong */ int system_call( struct handler_stack_frame* frame ) { int system_call_number; char** system_call_params; int* system_call_result; system_call_result = (int*)frame->ecx; system_call_params = (char**)frame->ebx; system_call_number = frame->eax; switch( system_call_number ) { case SYS_SEMA_CREATE: *system_call_result = semaphore_create( (sema_handle*)system_call_params[0], (int)system_call_params[1] ); break; case SYS_SEMA_WAIT: *system_call_result = semaphore_wait( (int)system_call_params[0] ); break; case SYS_SEMA_SIGNAL: *system_call_result = semaphore_signal( (int)system_call_params[0] ); break; case SYS_SEMA_DESTROY: *system_call_result = semaphore_destroy( (int)system_call_params[0] ); break; case SYS_THREAD_EXIT: *system_call_result = sys_thread_exit(); break; case SYS_MSLEEP: *system_call_result = sys_msleep((uint)system_call_params[0] ); break; default: *system_call_result = FAILURE; break; } return SUCCESS; }
/* This is somewhat different to other ports: we have a main loop here: * a dedicated task that waits for packets to arrive. This would normally be * done from interrupt context with embedded hardware, but we don't get an * interrupt in windows for that :-) */ void main_loop() { #if !NO_SYS err_t err; sys_sem_t init_sem; #endif /* NO_SYS */ #if PPP_SUPPORT #if !USE_ETHERNET int count; u8_t rxbuf[1024]; #endif volatile int callClosePpp = 0; #endif /* PPP_SUPPORT */ /* initialize lwIP stack, network interfaces and applications */ #if NO_SYS lwip_init(); test_init(NULL); #else /* NO_SYS */ err = sys_sem_new(&init_sem, 0); tcpip_init(test_init, &init_sem); /* we have to wait for initialization to finish before * calling update_adapter()! */ sys_sem_wait(&init_sem); sys_sem_free(&init_sem); #endif /* NO_SYS */ /* MAIN LOOP for driver update (and timers if NO_SYS) */ while (!_kbhit()) { #if NO_SYS /* handle timers (already done in tcpip.c when NO_SYS=0) */ sys_check_timeouts(); #endif /* NO_SYS */ #if USE_ETHERNET #if !PCAPIF_RX_USE_THREAD /* check for packets and link status*/ pcapif_poll(&netif); /* When pcapif_poll comes back, there are not packets, so sleep to prevent 100% CPU load. Don't do this in an embedded system since it increases latency! */ sys_msleep(1); #else /* !PCAPIF_RX_USE_THREAD */ sys_msleep(50); #endif /* !PCAPIF_RX_USE_THREAD */ #else /* USE_ETHERNET */ #if 0 /* set this to 1 if PPP_INPROC_OWNTHREAD==0 or not defined (see ppp.c) */ /* try to read characters from serial line and pass them to PPPoS */ count = sio_read(ppp_sio, (u8_t*)rxbuf, 1024); if(count > 0) { pppos_input(ppp_desc, rxbuf, count); } else #endif { /* nothing received, give other tasks a chance to run */ sys_msleep(1); } #endif /* USE_ETHERNET */ #if !LWIP_NETIF_LOOPBACK_MULTITHREADING /* check for loopback packets on all netifs */ netif_poll_all(); #endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */ #if PPP_SUPPORT { int do_hup = 0; if(do_hup) { pppSigHUP(ppp_desc); do_hup = 0; } } if(callClosePpp && (ppp_desc >= 0)) { /* make sure to disconnect PPP before stopping the program... */ callClosePpp = 0; #if NO_SYS pppClose(ppp_desc); #else tcpip_callback_with_block(pppCloseCallback, (void*)ppp_desc, 0); #endif ppp_desc = -1; } #endif /* PPP_SUPPORT */ } #if PPP_SUPPORT if(ppp_desc >= 0) { u32_t started; printf("Closing PPP connection...\n"); /* make sure to disconnect PPP before stopping the program... */ #if NO_SYS pppClose(ppp_desc); #else tcpip_callback_with_block(pppCloseCallback, (void*)ppp_desc, 0); #endif ppp_desc = -1; /* Wait for some time to let PPP finish... */ started = sys_now(); do { #if USE_ETHERNET && !PCAPIF_RX_USE_THREAD pcapif_poll(&netif); #else /* USE_ETHERNET && !PCAPIF_RX_USE_THREAD */ sys_msleep(50); #endif /* USE_ETHERNET && !PCAPIF_RX_USE_THREAD */ /* @todo: need a better check here: only wait until PPP is down */ } while(sys_now() - started < 5000); } #endif /* PPP_SUPPORT */ #if USE_ETHERNET /* release the pcap library... */ pcapif_shutdown(&netif); #endif /* USE_ETHERNET */ }
void uip_task(void *p) { int i; struct timer periodic_timer, arp_timer; enc28j60_open(); timer_set(&periodic_timer, CLOCK_SECOND / 2); timer_set(&arp_timer, CLOCK_SECOND * 10); while(1) { socket_process_pending_lists_(); uip_len = enc28j60_read(); if(uip_len > 0) { if(BUF->type == htons(UIP_ETHTYPE_IP)) { uip_input(); /* If the above function invocation resulted in data that should be sent out on the network, the global variable uip_len is set to a value > 0. */ if(uip_len > 0) { uip_arp_out(); enc28j60_write(); } } else if(BUF->type == htons(UIP_ETHTYPE_ARP)) { uip_arp_arpin(); /* If the above function invocation resulted in data that should be sent out on the network, the global variable uip_len is set to a value > 0. */ if(uip_len > 0) { enc28j60_write(); } } } if(timer_expired(&periodic_timer)) { timer_reset(&periodic_timer); for(i = 0; i < UIP_CONNS; i++) { uip_periodic(i); /* If the above function invocation resulted in data that should be sent out on the network, the global variable uip_len is set to a value > 0. */ if(uip_len > 0) { uip_arp_out(); enc28j60_write(); } } #if UIP_UDP for(i = 0; i < UIP_UDP_CONNS; i++) { uip_udp_periodic(i); /* If the above function invocation resulted in data that should be sent out on the network, the global variable uip_len is set to a value > 0. */ if(uip_len > 0) { uip_arp_out(); enc28j60_write(); } } #endif /* UIP_UDP */ /* Call the ARP timer function every 10 seconds. */ if(timer_expired(&arp_timer)) { timer_reset(&arp_timer); uip_arp_timer(); } } //yield so that other tasks can do something sys_msleep(UIP_TASK_YIELD_TIME_MS); } }
void* default_unli_handler (void* arg) { void* retr = NULL; long proc_id = (long)arg; if (OraDBDefaultUnli::init_lib() < 0) { LOG_CRITICAL("%s: %d: Unable to initialize libsqlora8!", __func__, proc_id); DO_ABORT(); return retr; } OraDBDefaultUnli conn; if (conn.initialize(Config::getOraAuth()) < 0) { LOG_CRITICAL("%s: %d: Unable to connect to db (%s).", __func__, proc_id, Config::getOraAuth()); DO_ABORT(); return retr; } LOG_INFO("%s: %d: Started.", __func__, proc_id); while (! IS_SHUTDOWN()) { default_unli_t default_unli; while (! c2q_dequeue(Global::getDefaultUnliQ(), &default_unli, sizeof(default_unli_t))) { if (! strcmp(default_unli.mcc, "515")) { LOG_DEBUG("%s: %d: Ignoring records with mcc 515: msisdn: %s, mnc: %s, mcc: %s, sgsn_ip: %s, tac_tai: %s, date: %s, filename: %s", __func__, proc_id , default_unli.msisdn, default_unli.mnc, default_unli.mcc, default_unli.sgsn_ip, default_unli.tac_tai, default_unli.date, default_unli.filename); continue; } //-- process default unli transaction... conn.processDefaultUnli(&default_unli); LOG_DEBUG("%s: %d: db_retr: %d, msisdn: %s, mnc: %s, mcc: %s, sgsn_ip: %s, tac_tai: %s, date: %s, filename: %s", __func__, proc_id , default_unli.db_retr, default_unli.msisdn, default_unli.mnc, default_unli.mcc, default_unli.sgsn_ip, default_unli.tac_tai , default_unli.date, default_unli.filename); switch (default_unli.db_retr) { case DB_RETR_NF_BUS: //-- call NF Bus... doNfBus(&default_unli); //if (0 == doNfBus(&default_unli)) { // send_system_msg("TRIGGER", TRAN_TYPE_BROADCAST, 0, // Config::getAccessCode(), default_unli.msisdn, SYSMSG_BROADCAST_ROAM_FREE_CT, 1); //} //-- continue... case DB_RETR_OK: //-- call matrix api... doMatrix(&default_unli); break; default: LOG_ERROR("%s: %d: Unable to process default_unli: retr: %d, msisdn: %s, mnc: %s, mcc: %s, sgsn_ip: %s, tac_tai: %s, date: %s, filename: %s", __func__, proc_id , default_unli.db_retr, default_unli.msisdn, default_unli.mnc, default_unli.mcc, default_unli.sgsn_ip, default_unli.tac_tai , default_unli.date, default_unli.filename); } } //-- sleep for a while sys_msleep(1000); } LOG_INFO("%s: %d: Terminated.", __func__, proc_id); conn.destroy_db(); return retr; }
/* * check_passwd - Check the user name and passwd against the PAP secrets * file. If requested, also check against the system password database, * and login the user if OK. * * returns: * UPAP_AUTHNAK: Authentication failed. * UPAP_AUTHACK: Authentication succeeded. * In either case, msg points to an appropriate message. */ int check_passwd( int unit, char *auser, int userlen, char *apasswd, int passwdlen, char **msg, int *msglen) { #if 1 LWIP_UNUSED_ARG(unit); LWIP_UNUSED_ARG(auser); LWIP_UNUSED_ARG(userlen); LWIP_UNUSED_ARG(apasswd); LWIP_UNUSED_ARG(passwdlen); LWIP_UNUSED_ARG(msglen); *msg = (char *) 0; return UPAP_AUTHACK; /* XXX Assume all entries OK. */ #else int ret = 0; struct wordlist *addrs = NULL; char passwd[256], user[256]; char secret[MAXWORDLEN]; static u_short attempts = 0; /* * Make copies of apasswd and auser, then null-terminate them. */ BCOPY(apasswd, passwd, passwdlen); passwd[passwdlen] = '\0'; BCOPY(auser, user, userlen); user[userlen] = '\0'; *msg = (char *) 0; /* XXX Validate user name and password. */ ret = UPAP_AUTHACK; /* XXX Assume all entries OK. */ if (ret == UPAP_AUTHNAK) { if (*msg == (char *) 0) { *msg = "Login incorrect"; } *msglen = strlen(*msg); /* * Frustrate passwd stealer programs. * Allow 10 tries, but start backing off after 3 (stolen from login). * On 10'th, drop the connection. */ if (attempts++ >= 10) { AUTHDEBUG((LOG_WARNING, "%d LOGIN FAILURES BY %s\n", attempts, user)); /*ppp_panic("Excess Bad Logins");*/ } if (attempts > 3) { sys_msleep((attempts - 3) * 5); } if (addrs != NULL) { free_wordlist(addrs); } } else { attempts = 0; /* Reset count */ if (*msg == (char *) 0) { *msg = "Login ok"; } *msglen = strlen(*msg); set_allowed_addrs(unit, addrs); } BZERO(passwd, sizeof(passwd)); BZERO(secret, sizeof(secret)); return ret; #endif }
void* default_unli_fetcher (void* arg) { void* retr = NULL; std::vector<std::string> list; std::string pattern = std::string(Config::getLocalDir()) + std::string("/*Gi*.csv"); default_unli_t default_unli; if (OraDBDefaultUnli::init_lib() < 0) { LOG_CRITICAL("%s: Unable to initialize libsqlora8!", __func__); DO_ABORT(); return retr; } OraDBDefaultUnli conn; if (conn.initialize(Config::getOraAuth()) < 0) { LOG_CRITICAL("%s: Unable to connect to db (%s).", __func__, Config::getOraAuth()); DO_ABORT(); return retr; } LOG_INFO("%s: Started.", __func__); LOG_INFO("%s: processing %s files.", __func__, pattern.c_str()); while (! IS_SHUTDOWN()) { glob(list, pattern); //LOG_DEBUG("%s: got %d files.", __func__, list.size()); for (size_t i=0; i < list.size(); ++i) { std::string &src = list[i]; std::string filename = basename(src); //-- check if already processed... memset(&default_unli, 0, sizeof(default_unli_t)); snprintf(default_unli.filename, sizeof(default_unli.filename), "%s", filename.c_str()); if (conn.getLastFileProcessed(&default_unli) < 0) { LOG_ERROR("%s: Unable to get last default_unli file: retr: %d, filename: %s", __func__ , default_unli.db_retr, default_unli.filename); } else { int status = default_unli.db_retr; if (1 != status) { LOG_DEBUG("%s: Ignoring previously processed file: %s", __func__, default_unli.filename); } std::string processed = Config::getLocalProcessedDir() + filename; std::string ignored = Config::getLocalIgnoredDir() + filename; std::string &dest = (1 == status) ? processed : ignored; if (0 != mv(src, dest)) { LOG_ERROR("%s: Unable to move '%s' to '%s'", __func__, src.c_str(), dest.c_str()); } } } //-- sleep for a while sys_msleep(1000); } LOG_INFO("%s: Terminated.", __func__); conn.destroy_db(); return retr; }