int main(void)
{
tmr_t test_timer, test_timer_2, test_timer_3;
printf("System abstraction test - POSIX implementation\n");
system_init();
tmr_init(&test_timer, true, test, NULL);
tmr_start(test_timer, 100);
tmr_init(&test_timer_2, true, test_2, NULL);
tmr_start(test_timer_2, 275);
tmr_init(&test_timer_3, false, test_3, NULL);
tmr_start(test_timer_3, 1000);
tmr_stop(test_timer);
tmr_reset(test_timer);
system_start();
tmr_destroy(test_timer);
tmr_destroy(test_timer_2);
tmr_destroy(test_timer_3);
return 0;
}
int rtcp_sess_alloc(struct rtcp_sess **sessp, struct rtp_sock *rs)
{
struct rtcp_sess *sess;
int err;
if (!sessp)
return EINVAL;
sess = mem_zalloc(sizeof(*sess), sess_destructor);
if (!sess)
return ENOMEM;
sess->rs = rs;
tmr_init(&sess->tmr);
err = lock_alloc(&sess->lock);
if (err)
goto out;
err = hash_alloc(&sess->members, MAX_MEMBERS);
if (err)
goto out;
out:
if (err)
mem_deref(sess);
else
*sessp = sess;
return err;
}
/**
* Add TURN Permission for a peer
*
* @param turnc TURN Client
* @param peer Peer IP-address
* @param ph Permission handler
* @param arg Handler argument
*
* @return 0 if success, otherwise errorcode
*/
int turnc_add_perm(struct turnc *turnc, const struct sa *peer,
turnc_perm_h *ph, void *arg)
{
struct perm *perm;
int err;
if (!turnc || !peer)
return EINVAL;
if (perm_find(turnc, peer))
return 0;
perm = mem_zalloc(sizeof(*perm), destructor);
if (!perm)
return ENOMEM;
hash_append(turnc->perms, sa_hash(peer, SA_ADDR), &perm->he, perm);
tmr_init(&perm->tmr);
perm->peer = *peer;
perm->turnc = turnc;
perm->ph = ph;
perm->arg = arg;
err = createperm_request(perm, true);
if (err)
mem_deref(perm);
return err;
}
static int ui_alloc(struct ui_st **stp)
{
struct ui_st *st;
int err;
if (!stp)
return EINVAL;
st = mem_zalloc(sizeof(*st), ui_destructor);
if (!st)
return ENOMEM;
tmr_init(&st->tmr);
err = fd_listen(STDIN_FILENO, FD_READ, ui_fd_handler, st);
if (err)
goto out;
err = term_setup(st);
if (err) {
info("stdio: could not setup terminal: %m\n", err);
err = 0;
}
out:
if (err)
mem_deref(st);
else
*stp = st;
return err;
}
int main (void)
{
uint32_t now, led_ms; // ms
unsigned char c;
DDRB |= 1 << 7; // Arduino pin 13
uart0_init();
tmr_init();
sei();
printf("hello world\n");
led_ms = tmr_count_ms();
while (1) {
now = tmr_count_ms();
if ((now - led_ms) >= 1000) {
led_ms = now;
PORTB ^= 1 << 7; // Arduino pin 13
printf("%ld ms\n", now);
}
c = uart_getchar();
if (c) {
uart_putchar(c);
}
}
return 0;
}
FragInfo_t *rfraginfo_create (CCREF *refp,
DataFragSMsg *fragp,
unsigned max_frags)
{
DB *dbp;
FragInfo_t *fip;
dbp = db_alloc_data (fragp->sample_size, 1);
if (!dbp) {
warn_printf ("rfraginfo_create: no memory for sample data!");
return (NULL);
}
fip = xmalloc (FRAG_INFO_SIZE (max_frags));
if (!fip) {
warn_printf ("rfraginfo_create: no memory for fragment info!");
db_free_data (dbp);
return (NULL);
}
memset (fip, 0, FRAG_INFO_SIZE (max_frags));
fip->nrefs = 1;
fip->total = fip->num_na = max_frags;
fip->fsize = fragp->frag_size;
if (refp->relevant)
fip->writer = refp->u.c.change->c_writer;
else
fip->writer = 0;
fip->data = dbp;
fip->length = fragp->sample_size;
tmr_init (&fip->timer, "FragInfo");
refp->fragments = fip;
return (fip);
}
/*
* Application entry point.
*/
int main(void) {
static const evhandler_t evhndl[] = {
TimerHandler,
InsertHandler,
RemoveHandler
};
static EvTimer evt;
struct EventListener el0, el1, el2;
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Activates the serial driver 1 using the driver default configuration.
*/
sdStart(&SD1, NULL);
/*
* Buzzer driver initialization.
*/
buzzInit();
/*
* Initializes the MMC driver to work with SPI2.
*/
mmcObjectInit(&MMCD1);
mmcStart(&MMCD1, &mmccfg);
/*
* Activates the card insertion monitor.
*/
tmr_init(&MMCD1);
/*
* Creates the blinker threads.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, NULL);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and listen for events.
*/
evtInit(&evt, MS2ST(500)); /* Initializes an event timer object. */
evtStart(&evt); /* Starts the event timer. */
chEvtRegister(&evt.et_es, &el0, 0); /* Registers on the timer event source. */
chEvtRegister(&inserted_event, &el1, 1);
chEvtRegister(&removed_event, &el2, 2);
while (TRUE)
chEvtDispatch(evhndl, chEvtWaitOne(ALL_EVENTS));
return 0;
}
static void init_policy_list (void)
{
if (!list_init) {
tmr_init (&tmr_policy, "Policy Timer");
LIST_INIT (policy_list);
DDS_Security_register_policy_version (qeo_receive_policy_version);
}
list_init = 1;
}
/*
* Application entry point.
*/
int main(void) {
static const evhandler_t evhndl[] = {
InsertHandler,
RemoveHandler
};
Thread *shelltp = NULL;
struct EventListener el0, el1;
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Activates the serial driver 1 and SDC driver 1 using default
* configuration.
*/
sdStart(&SD1, NULL);
sdcStart(&SDCD1, NULL);
/*
* Shell manager initialization.
*/
shellInit();
/*
* Activates the card insertion monitor.
*/
tmr_init(&SDCD1);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and listen for events.
*/
chEvtRegister(&inserted_event, &el0, 0);
chEvtRegister(&removed_event, &el1, 1);
while (TRUE) {
if (!shelltp)
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
else if (chThdTerminated(shelltp)) {
chThdRelease(shelltp); /* Recovers memory of the previous shell. */
shelltp = NULL; /* Triggers spawning of a new shell. */
}
chEvtDispatch(evhndl, chEvtWaitOne(ALL_EVENTS));
}
}
int di_sys_init (void)
{
ipv4.fct = NULL;
#ifdef DDS_IPV6
ipv6.fct = NULL;
#endif
tmr_init (&poll_timer, "DynIP.poll");
return (DDS_RETCODE_OK);
}
/**
* Add a new ICE Media object to the ICE Session
*
* @param icemp Pointer to allocated ICE Media object
* @param ice ICE Session
* @param proto Transport protocol
* @param layer Protocol stack layer
* @param gh Gather handler
* @param chkh Connectivity check handler
* @param arg Handler argument
*
* @return 0 if success, otherwise errorcode
*/
int icem_alloc(struct icem **icemp, struct ice *ice, int proto, int layer,
ice_gather_h *gh, ice_connchk_h *chkh, void *arg)
{
struct icem *icem;
int err = 0;
if (!ice)
return EINVAL;
if (proto != IPPROTO_UDP)
return EPROTONOSUPPORT;
icem = mem_zalloc(sizeof(*icem), icem_destructor);
if (!icem)
return ENOMEM;
tmr_init(&icem->tmr_pace);
list_init(&icem->lcandl);
list_init(&icem->rcandl);
list_init(&icem->checkl);
list_init(&icem->validl);
icem->ice = ice;
icem->layer = layer;
icem->proto = proto;
icem->state = CHECKLIST_NULL;
icem->nstun = 0;
icem->gh = gh;
icem->chkh = chkh;
icem->arg = arg;
if (ICE_MODE_FULL == ice->lmode) {
err = stun_alloc(&icem->stun, NULL, NULL, NULL);
if (err)
goto out;
/* Update STUN Transport */
stun_conf(icem->stun)->rto = ice->conf.rto;
stun_conf(icem->stun)->rc = ice->conf.rc;
}
if (err)
goto out;
list_append(&ice->ml, &icem->le, icem);
out:
if (err)
mem_deref(icem);
else if (icemp)
*icemp = icem;
return err;
}
int dtls_flow_alloc(struct dtls_flow **flowp, struct tls *tls,
struct udp_sock *us, dtls_estab_h *estabh, void *arg)
{
struct dtls_flow *flow;
int err = ENOMEM;
if (!flowp || !tls || !us || !estabh)
return EINVAL;
flow = mem_zalloc(sizeof(*flow), destructor);
if (!flow)
return ENOMEM;
flow->tls = tls;
flow->us = mem_ref(us);
flow->estabh = estabh;
flow->arg = arg;
err = udp_register_helper(&flow->uh, us, LAYER_DTLS, NULL,
recv_handler, flow);
if (err)
goto out;
flow->ssl = SSL_new(tls->ctx);
if (!flow->ssl) {
ERR_clear_error();
goto out;
}
flow->sbio_in = BIO_new(BIO_s_mem());
if (!flow->sbio_in)
goto out;
flow->sbio_out = BIO_new(&bio_udp_send);
if (!flow->sbio_out) {
BIO_free(flow->sbio_in);
goto out;
}
flow->sbio_out->ptr = flow;
SSL_set_bio(flow->ssl, flow->sbio_in, flow->sbio_out);
tmr_init(&flow->tmr);
err = 0;
out:
if (err)
mem_deref(flow);
else
*flowp = flow;
return err;
}
void init_fatfs( void )
{
// Activates the SDC driver 1 using default configuration.
sdcStart( &SDCD1, NULL );
// Activates the card insertion monitor.
tmr_init( &SDCD1 );
chEvtRegister( &inserted_event, &el0, 0 );
chEvtRegister( &removed_event, &el1, 1 );
}
int re_main_timeout(uint32_t timeout)
{
struct tmr tmr;
int err = 0;
tmr_init(&tmr);
tmr_start(&tmr, timeout * 1000, timeout_handler, &err);
re_main(NULL);
tmr_cancel(&tmr);
return err;
}
int re_main_timeout(uint32_t timeout_ms)
{
struct tmr tmr;
int err = 0;
tmr_init(&tmr);
tmr_start(&tmr, timeout_ms, timeout_handler, &err);
re_main(signal_handler);
tmr_cancel(&tmr);
return err;
}
int mm_platform_init(struct mm *mm, struct dict *sounds)
{
info("mm_platform_android: init: mm=%p sounds=%p\n", mm, sounds);
tmr_init(&java.tmr_delay);
jni_create_router(mm);
dict_flush(sounds);
mediamgr_device_changed(mm);
return 0;
}
/**
* Play a tone from a PCM buffer
*
* @param playp Pointer to allocated player object
* @param tone PCM buffer to play
* @param srate Sampling rate
* @param ch Number of channels
* @param repeat Number of times to repeat
*
* @return 0 if success, otherwise errorcode
*/
int play_tone(struct play **playp, struct mbuf *tone, uint32_t srate,
uint8_t ch, int repeat)
{
struct auplay_prm wprm;
struct play *play;
int err;
if (playp && *playp)
return EALREADY;
play = mem_zalloc(sizeof(*play), destructor);
if (!play)
return ENOMEM;
tmr_init(&play->tmr);
play->repeat = repeat;
play->mb = mem_ref(tone);
err = lock_alloc(&play->lock);
if (err)
goto out;
wprm.fmt = AUFMT_S16LE;
wprm.ch = ch;
wprm.srate = srate;
wprm.frame_size = srate * ch * 100 / 1000;
err = auplay_alloc(&play->auplay, cfg_audio.alert_mod, &wprm,
cfg_audio.alert_dev, write_handler, play);
if (err)
goto out;
list_append(&playl, &play->le, play);
tmr_start(&play->tmr, 1000, tmr_polling, play);
out:
if (err) {
mem_deref(play);
}
else if (playp) {
play->playp = playp;
*playp = play;
}
return err;
}
static int presence_alloc(struct contact *contact)
{
struct presence *pres;
pres = mem_zalloc(sizeof(*pres), destructor);
if (!pres)
return ENOMEM;
pres->status = PRESENCE_UNKNOWN;
pres->contact = mem_ref(contact);
tmr_init(&pres->tmr);
tmr_start(&pres->tmr, 1000, tmr_handler, pres);
list_append(&presencel, &pres->le, pres);
return 0;
}
static int publisher_alloc(struct ua *ua)
{
struct publisher *pub;
pub = mem_zalloc(sizeof(*pub), destructor);
if (!pub)
return ENOMEM;
pub->ua = mem_ref(ua);
pub->expires = account_pubint(ua_account(ua));
tmr_init(&pub->tmr);
tmr_start(&pub->tmr, 10, tmr_handler, pub);
list_append(&publ, &pub->le, pub);
return 0;
}
int main(void)
{
// Set BUZZER_O as output pin
DDR_BUZZER_O |= (1<<BIT_BUZZER_O);
// Disable Buzzer
PORT_BUZZER_O |= (1<<BIT_BUZZER_O);
// Initialise timer
tmr_init();
// Repeat indefinitely
for(;;)
{
beep();
// Wait 1 s
tmr_delay(1000);
}
}
static void sfr_rel_start (RemWriter_t *rwp)
{
Reader_t *r = (Reader_t *) (rwp->rw_reader->endpoint.endpoint);
ctrc_printd (RTPS_ID, RTPS_SFR_REL_START, &rwp, sizeof (rwp));
prof_start (rtps_rr_start);
RW_SIGNAL (rwp, "REL-Start");
#ifdef RTPS_MARKERS
if (rwp->rw_reader->endpoint.mark_start)
rtps_marker_notify (rwp->rw_reader->endpoint.endpoint, EM_START, "sfr_rel_start");
#endif
NEW_RW_CSTATE (rwp, RWCS_INITIAL, 1);
LIST_INIT (rwp->rw_changes);
rwp->rw_changes.nchanges = 0;
NEW_RW_CSTATE (rwp, RWCS_READY, 0);
NEW_RW_ASTATE (rwp, RWAS_WAITING, 0);
rwp->rw_hb_no_data = 0;
rwp->rw_hbrsp_timer = NULL;
#ifdef RTPS_PROXY_INST
rwp->rw_loc_inst = ++rtps_rw_insts;
#endif
#ifdef RTPS_INIT_ACKNACK
/* Send an initial ACKNACK to bootstrap the protocol in case the writer
was already active, but we missed the initial HEARTBEAT! */
rwp->rw_peer_alive = 0;
sfr_rel_init_acknack (rwp);
RALIVE_TMR_ALLOC (rwp);
rwp->rw_hbrsp_timer = tmr_alloc ();
if (rwp->rw_hbrsp_timer) {
tmr_init (rwp->rw_hbrsp_timer, "RTPS-RAlive");
RALIVE_TMR_START (rwp, rwp->rw_hbrsp_timer, RALIVE_TO,
(uintptr_t) rwp, sfr_rel_alive_to, &r->r_lock);
}
#endif
prof_stop (rtps_rr_start, 1);
}
static int ui_alloc(struct ui_st **stp)
{
struct ui_st *st;
DWORD threadID;
int err = 0;
if (!stp)
return EINVAL;
st = mem_zalloc(sizeof(*st), destructor);
if (!st)
return ENOMEM;
tmr_init(&st->tmr);
err = mqueue_alloc(&st->mq, mqueue_handler, st);
if (err)
goto out;
st->hstdin = GetStdHandle(STD_INPUT_HANDLE);
/* save the current console mode */
GetConsoleMode(st->hstdin, &st->mode);
st->run = true;
st->hThread = CreateThread(NULL, 0, input_thread, st, 0, &threadID);
if (!st->hThread) {
st->run = false;
err = ENOMEM;
goto out;
}
out:
if (err)
mem_deref(st);
else
*stp = st;
return err;
}
static int session_alloc(struct menc_sess **sessp, struct sdp_session *sdp,
bool offerer, menc_event_h *eventh,
menc_error_h *errorh, void *arg)
{
struct menc_sess *st;
zrtp_status_t s;
int err = 0;
(void)offerer;
if (!sessp || !sdp)
return EINVAL;
st = mem_zalloc(sizeof(*st), session_destructor);
if (!st)
return ENOMEM;
st->eventh = eventh;
st->errorh = errorh;
st->arg = arg;
st->err = 0;
tmr_init(&st->abort_timer);
s = zrtp_session_init(zrtp_global, NULL, zid,
ZRTP_SIGNALING_ROLE_UNKNOWN, &st->zrtp_session);
if (s != zrtp_status_ok) {
warning("zrtp: zrtp_session_init failed (status = %d)\n", s);
err = EPROTO;
goto out;
}
out:
if (err)
mem_deref(st);
else
*sessp = st;
return err;
}
static struct tls_conn *conn_alloc(struct tls_sock *ts, const struct sa *peer)
{
struct tls_conn *tc;
tc = mem_zalloc(sizeof(*tc), conn_destructor);
if (!tc)
return NULL;
tc->ssl = SSL_new(ts->tls->ctx);
if (!tc->ssl)
goto error;
tc->sbio_in = BIO_new(BIO_s_mem());
if (!tc->sbio_in)
goto error;
tc->sbio_out = BIO_new(&bio_udp_send);
if (!tc->sbio_out) {
BIO_free(tc->sbio_in);
goto error;
}
tc->sbio_out->ptr = tc;
SSL_set_bio(tc->ssl, tc->sbio_in, tc->sbio_out);
tmr_init(&tc->tmr);
tc->peer = *peer;
tc->ts = ts;
hash_append(ts->ht_conn, sa_hash(peer, SA_ALL), &tc->he, tc);
return tc;
error:
return mem_deref(tc);
}
static int module_init(void)
{
int err = 0;
struct config *cfg = conf_config();
webapp_accounts_init();
#if defined (DARWIN)
re_snprintf(command, sizeof(command), "open https://stream.studio-link.de/stream/login/%s",
cfg->sip.uuid);
#elif defined (WIN32)
re_snprintf(command, sizeof(command), "start https://stream.studio-link.de/stream/login/%s",
cfg->sip.uuid);
#else
re_snprintf(command, sizeof(command), "xdg-open https://stream.studio-link.de/stream/login/%s",
cfg->sip.uuid);
#endif
tmr_init(&tmr);
tmr_start(&tmr, 1500, startup, NULL);
return err;
}
/**
* Allocate a new Call state object
*
* @param callp Pointer to allocated Call state object
* @param cfg Global configuration
* @param lst List of call objects
* @param local_name Local display name (optional)
* @param local_uri Local SIP uri
* @param acc Account parameters
* @param ua User-Agent
* @param prm Call parameters
* @param msg SIP message for incoming calls
* @param xcall Optional call to inherit properties from
* @param eh Call event handler
* @param arg Handler argument
*
* @return 0 if success, otherwise errorcode
*/
int call_alloc(struct call **callp, const struct config *cfg, struct list *lst,
const char *local_name, const char *local_uri,
struct account *acc, struct ua *ua, const struct call_prm *prm,
const struct sip_msg *msg, struct call *xcall,
call_event_h *eh, void *arg)
{
struct call *call;
enum vidmode vidmode = prm ? prm->vidmode : VIDMODE_OFF;
bool use_video = true, got_offer = false;
int label = 0;
int err = 0;
if (!cfg || !local_uri || !acc || !ua)
return EINVAL;
call = mem_zalloc(sizeof(*call), call_destructor);
if (!call)
return ENOMEM;
MAGIC_INIT(call);
call->config_avt = cfg->avt;
tmr_init(&call->tmr_inv);
call->acc = mem_ref(acc);
call->ua = ua;
call->state = STATE_IDLE;
call->eh = eh;
call->arg = arg;
call->af = prm ? prm->af : AF_INET;
err = str_dup(&call->local_uri, local_uri);
if (local_name)
err |= str_dup(&call->local_name, local_name);
if (err)
goto out;
/* Init SDP info */
err = sdp_session_alloc(&call->sdp, net_laddr_af(call->af));
if (err)
goto out;
err = sdp_session_set_lattr(call->sdp, true,
"tool", "baresip " BARESIP_VERSION);
if (err)
goto out;
/* Check for incoming SDP Offer */
if (msg && mbuf_get_left(msg->mb))
got_offer = true;
/* Initialise media NAT handling */
if (acc->mnat) {
err = acc->mnat->sessh(&call->mnats, net_dnsc(), call->af,
acc->stun_host, acc->stun_port,
acc->stun_user, acc->stun_pass,
call->sdp, !got_offer,
mnat_handler, call);
if (err) {
warning("call: medianat session: %m\n", err);
goto out;
}
}
call->mnat_wait = true;
/* Media encryption */
if (acc->menc) {
if (acc->menc->sessh) {
err = acc->menc->sessh(&call->mencs, call->sdp,
!got_offer,
menc_error_handler, call);
if (err) {
warning("call: mediaenc session: %m\n", err);
goto out;
}
}
}
/* Audio stream */
err = audio_alloc(&call->audio, cfg, call,
call->sdp, ++label,
acc->mnat, call->mnats, acc->menc, call->mencs,
acc->ptime, account_aucodecl(call->acc),
audio_event_handler, audio_error_handler, call);
if (err)
goto out;
#ifdef USE_VIDEO
/* We require at least one video codec, and at least one
video source or video display */
use_video = (vidmode != VIDMODE_OFF)
&& (list_head(account_vidcodecl(call->acc)) != NULL)
&& (NULL != vidsrc_find(NULL) || NULL != vidisp_find(NULL));
/* Video stream */
if (use_video) {
err = video_alloc(&call->video, cfg,
call, call->sdp, ++label,
acc->mnat, call->mnats,
acc->menc, call->mencs,
"main",
account_vidcodecl(call->acc),
video_error_handler, call);
if (err)
goto out;
}
if (str_isset(cfg->bfcp.proto)) {
err = bfcp_alloc(&call->bfcp, call->sdp,
cfg->bfcp.proto, !got_offer,
acc->mnat, call->mnats);
if (err)
goto out;
}
#else
(void)use_video;
(void)vidmode;
#endif
/* inherit certain properties from original call */
if (xcall) {
call->not = mem_ref(xcall->not);
}
list_append(lst, &call->le, call);
out:
if (err)
mem_deref(call);
else if (callp)
*callp = call;
return err;
}
int main(void) {
static Thread *shelltp = NULL;
static const evhandler_t evhndl[] = {
InsertHandler,
RemoveHandler,
packetReceivedHandler
};
struct EventListener el0, el1, el2;
chEvtRegister(&packet_event, &el2, 0);
chEvtInit(&packet_event);
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Initializes a serial-over-USB CDC driver.
*/
sduObjectInit(&SDU1);
sduStart(&SDU1, &serusbcfg);
/*
* Activates the USB driver and then the USB bus pull-up on D+.
* Note, a delay is inserted in order to not have to disconnect the cable
* after a reset.
*/
usbDisconnectBus(serusbcfg.usbp);
chThdSleepMilliseconds(1000);
usbStart(serusbcfg.usbp, &usbcfg);
usbConnectBus(serusbcfg.usbp);
/*
* Shell manager initialization.
*/
shellInit();
/*
* Activates the serial driver 6 and SDC driver 1 using default
* configuration.
*/
sdStart(&SD6, NULL);
sdcStart(&SDCD1, NULL);
/*
* Activates the card insertion monitor.
*/
tmr_init(&SDCD1);
/*
* Creates the blinker thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Creates the LWIP threads (it changes priority internally).
*/
chThdCreateStatic(wa_lwip_thread, LWIP_THREAD_STACK_SIZE, NORMALPRIO + 2,
lwip_thread, NULL);
/*
* Creates the HTTP thread (it changes priority internally).
*/
/*
chThdCreateStatic(wa_http_server, sizeof(wa_http_server), NORMALPRIO + 1,
http_server, NULL);
*/
WORKING_AREA(wa_udp_receive_server, PWM_REC_STACK_SIZE);
chThdCreateStatic(wa_udp_receive_server, sizeof(wa_udp_receive_server), NORMALPRIO +1,
udp_receive_server_init, NULL);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and listen for events.
*/
chEvtRegister(&inserted_event, &el0, 0);
chEvtRegister(&removed_event, &el1, 1);
while (TRUE) {
if (!shelltp && (SDU1.config->usbp->state == USB_ACTIVE))
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
else if (chThdTerminated(shelltp)) {
chThdRelease(shelltp); /* Recovers memory of the previous shell. */
shelltp = NULL; /* Triggers spawning of a new shell. */
}
if (palReadPad(GPIOA, GPIOA_BUTTON_WKUP) != 0) {
}
chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500)));
}
}
/**
* Allocate a TURN Client
*
* @param turncp Pointer to allocated TURN Client
* @param conf Optional STUN Configuration
* @param proto Transport Protocol
* @param sock Transport socket
* @param layer Transport layer
* @param srv TURN Server IP-address
* @param username Authentication username
* @param password Authentication password
* @param lifetime Allocate lifetime in [seconds]
* @param th TURN handler
* @param arg Handler argument
*
* @return 0 if success, otherwise errorcode
*/
int turnc_alloc(struct turnc **turncp, const struct stun_conf *conf, int proto,
void *sock, int layer, const struct sa *srv,
const char *username, const char *password,
uint32_t lifetime, turnc_h *th, void *arg)
{
struct turnc *turnc;
int err;
if (!turncp || !sock || !srv || !username || !password || !th)
return EINVAL;
turnc = mem_zalloc(sizeof(*turnc), destructor);
if (!turnc)
return ENOMEM;
err = stun_alloc(&turnc->stun, conf, NULL, NULL);
if (err)
goto out;
err = str_dup(&turnc->username, username);
if (err)
goto out;
err = str_dup(&turnc->password, password);
if (err)
goto out;
err = turnc_perm_hash_alloc(&turnc->perms, PERM_HASH_SIZE);
if (err)
goto out;
err = turnc_chan_hash_alloc(&turnc->chans, CHAN_HASH_SIZE);
if (err)
goto out;
tmr_init(&turnc->tmr);
turnc->proto = proto;
turnc->sock = mem_ref(sock);
turnc->psrv = *srv;
turnc->srv = *srv;
turnc->lifetime = lifetime;
turnc->th = th;
turnc->arg = arg;
switch (proto) {
case IPPROTO_UDP:
err = udp_register_helper(&turnc->uh, sock, layer,
udp_send_handler, udp_recv_handler,
turnc);
break;
default:
err = 0;
break;
}
if (err)
goto out;
err = allocate_request(turnc);
if (err)
goto out;
out:
if (err)
mem_deref(turnc);
else
*turncp = turnc;
return err;
}
int
main( int argc, char** argv )
{
int argn;
int start;
#define START_NONE 0
#define START_PARALLEL 1
#define START_RATE 2
int start_parallel = -1, start_rate = -1;
int end;
#define END_NONE 0
#define END_FETCHES 1
#define END_SECONDS 2
int end_fetches = -1, end_seconds = -1;
int cnum;
char* url_file;
char* sip_file;
#ifdef RLIMIT_NOFILE
struct rlimit limits;
#endif /* RLIMIT_NOFILE */
fd_set rfdset;
fd_set wfdset;
struct timeval now;
int i, r;
max_connections = 64 - RESERVED_FDS; /* a guess */
#ifdef RLIMIT_NOFILE
/* Try and increase the limit on # of files to the maximum. */
if ( getrlimit( RLIMIT_NOFILE, &limits ) == 0 )
{
if ( limits.rlim_cur != limits.rlim_max )
{
if ( limits.rlim_max == RLIM_INFINITY )
limits.rlim_cur = 8192; /* arbitrary */
else if ( limits.rlim_max > limits.rlim_cur )
limits.rlim_cur = limits.rlim_max;
(void) setrlimit( RLIMIT_NOFILE, &limits );
}
max_connections = limits.rlim_cur - RESERVED_FDS;
}
#endif /* RLIMIT_NOFILE */
/* Parse args. */
argv0 = argv[0];
argn = 1;
do_checksum = do_throttle = do_verbose = do_jitter = do_proxy = 0;
throttle = THROTTLE;
sip_file = (char*) 0;
idle_secs = IDLE_SECS;
start = START_NONE;
end = END_NONE;
while ( argn < argc && argv[argn][0] == '-' && argv[argn][1] != '\0' )
{
if ( strncmp( argv[argn], "-checksum", strlen( argv[argn] ) ) == 0 )
do_checksum = 1;
else if ( strncmp( argv[argn], "-throttle", strlen( argv[argn] ) ) == 0 )
do_throttle = 1;
else if ( strncmp( argv[argn], "-Throttle", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
do_throttle = 1;
throttle = atoi( argv[++argn] ) / 10.0;
}
else if ( strncmp( argv[argn], "-verbose", strlen( argv[argn] ) ) == 0 )
do_verbose = 1;
else if ( strncmp( argv[argn], "-timeout", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
idle_secs = atoi( argv[++argn] );
else if ( strncmp( argv[argn], "-jitter", strlen( argv[argn] ) ) == 0 )
do_jitter = 1;
else if ( strncmp( argv[argn], "-parallel", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
start = START_PARALLEL;
start_parallel = atoi( argv[++argn] );
if ( start_parallel < 1 )
{
(void) fprintf(
stderr, "%s: parallel must be at least 1\n", argv0 );
exit( 1 );
}
if ( start_parallel > max_connections )
{
(void) fprintf(
stderr, "%s: parallel may be at most %d\n", argv0, max_connections );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-rate", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
start = START_RATE;
start_rate = atoi( argv[++argn] );
if ( start_rate < 1 )
{
(void) fprintf(
stderr, "%s: rate must be at least 1\n", argv0 );
exit( 1 );
}
if ( start_rate > 1000 )
{
(void) fprintf(
stderr, "%s: rate may be at most 1000\n", argv0 );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-fetches", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
end = END_FETCHES;
end_fetches = atoi( argv[++argn] );
if ( end_fetches < 1 )
{
(void) fprintf(
stderr, "%s: fetches must be at least 1\n", argv0 );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-seconds", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
end = END_SECONDS;
end_seconds = atoi( argv[++argn] );
if ( end_seconds < 1 )
{
(void) fprintf(
stderr, "%s: seconds must be at least 1\n", argv0 );
exit( 1 );
}
}
else if ( strncmp( argv[argn], "-sip", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
sip_file = argv[++argn];
#ifdef USE_SSL
else if ( strncmp( argv[argn], "-cipher", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
cipher = argv[++argn];
if ( strcasecmp( cipher, "fastsec" ) == 0 )
cipher = "RC4-MD5";
else if ( strcasecmp( cipher, "highsec" ) == 0 )
cipher = "DES-CBC3-SHA";
else if ( strcasecmp( cipher, "paranoid" ) == 0 )
cipher = "AES256-SHA";
}
#endif /* USE_SSL */
else if ( strncmp( argv[argn], "-proxy", strlen( argv[argn] ) ) == 0 && argn + 1 < argc )
{
char* colon;
do_proxy = 1;
proxy_hostname = argv[++argn];
colon = strchr( proxy_hostname, ':' );
if ( colon == (char*) 0 )
proxy_port = 80;
else
{
proxy_port = (unsigned short) atoi( colon + 1 );
*colon = '\0';
}
}
else
usage();
++argn;
}
if ( argn + 1 != argc )
usage();
if ( start == START_NONE || end == END_NONE )
usage();
if ( do_jitter && start != START_RATE )
usage();
url_file = argv[argn];
/* Read in and parse the URLs. */
printf("Loading url file...");
read_url_file( url_file );
printf("Total %d urls loaded.\n", num_urls);
/* Read in the source IP file, if specified. */
if ( sip_file != (char*) 0 )
read_sip_file( sip_file );
/* Initialize the connections table. */
if ( start == START_PARALLEL )
max_connections = start_parallel;
connections = (connection*) malloc_check(
max_connections * sizeof(connection) );
for ( cnum = 0; cnum < max_connections; ++cnum )
connections[cnum].conn_state = CNST_FREE;
num_connections = max_parallel = 0;
/* Initialize the HTTP status-code histogram. */
for ( i = 0; i < 1000; ++i )
http_status_counts[i] = 0;
/* Initialize the statistics. */
fetches_started = 0;
connects_completed = 0;
responses_completed = 0;
fetches_completed = 0;
total_bytes = 0;
total_connect_usecs = 0;
max_connect_usecs = 0;
min_connect_usecs = 1000000000L;
total_response_usecs = 0;
max_response_usecs = 0;
min_response_usecs = 1000000000L;
total_timeouts = 0;
total_badbytes = 0;
total_badchecksums = 0;
/* Initialize the random number generator. */
#ifdef HAVE_SRANDOMDEV
srandomdev();
#else
srandom( (int) time( (time_t*) 0 ) ^ getpid() );
#endif
/* Initialize the rest. */
tmr_init();
(void) gettimeofday( &now, (struct timezone*) 0 );
start_at = now;
if ( do_verbose )
(void) tmr_create(
&now, progress_report, JunkClientData, PROGRESS_SECS * 1000L, 1 );
if ( start == START_RATE )
{
start_interval = 1000L / start_rate;
if ( do_jitter )
{
low_interval = start_interval * 9 / 10;
high_interval = start_interval * 11 / 10;
range_interval = high_interval - low_interval + 1;
}
(void) tmr_create(
&now, start_timer, JunkClientData, start_interval, ! do_jitter );
}
if ( end == END_SECONDS )
(void) tmr_create(
&now, end_timer, JunkClientData, end_seconds * 1000L, 0 );
(void) signal( SIGPIPE, SIG_IGN );
/* Main loop. */
for (;;)
{
if ( end == END_FETCHES && fetches_completed >= end_fetches )
finish( &now );
if ( start == START_PARALLEL )
{
/* See if we need to start any new connections; but at most 10. */
for ( i = 0;
i < 10 &&
num_connections < start_parallel &&
( end != END_FETCHES || fetches_started < end_fetches );
++i )
{
start_connection( &now );
(void) gettimeofday( &now, (struct timezone*) 0 );
tmr_run( &now );
}
}
/* Build the fdsets. */
FD_ZERO( &rfdset );
FD_ZERO( &wfdset );
for ( cnum = 0; cnum < max_connections; ++cnum )
switch ( connections[cnum].conn_state )
{
case CNST_CONNECTING:
FD_SET( connections[cnum].conn_fd, &wfdset );
break;
case CNST_HEADERS:
case CNST_READING:
FD_SET( connections[cnum].conn_fd, &rfdset );
break;
}
r = select(
FD_SETSIZE, &rfdset, &wfdset, (fd_set*) 0, tmr_timeout( &now ) );
if ( r < 0 )
{
perror( "select" );
exit( 1 );
}
(void) gettimeofday( &now, (struct timezone*) 0 );
/* Service them. */
for ( cnum = 0; cnum < max_connections; ++cnum )
switch ( connections[cnum].conn_state )
{
case CNST_CONNECTING:
if ( FD_ISSET( connections[cnum].conn_fd, &wfdset ) )
handle_connect( cnum, &now, 1 );
break;
case CNST_HEADERS:
case CNST_READING:
if ( FD_ISSET( connections[cnum].conn_fd, &rfdset ) )
handle_read( cnum, &now );
break;
}
/* And run the timers. */
tmr_run( &now );
}
/* NOT_REACHED */
}
/*
* Application entry point.
*/
int main(void) {
static const evhandler_t evhndl[] = {
InsertHandler,
RemoveHandler
};
Thread *shelltp = NULL;
struct EventListener el0, el1;
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Activates the serial driver 1 using the driver default configuration.
*/
sdStart(&SD1, NULL);
/*
* Shell manager initialization.
*/
shellInit();
/*
* Initializes the MMC driver to work with SPI.
*/
palSetPadMode(IOPORT1, PIOA_CS_MMC, PAL_MODE_OUTPUT_PUSHPULL);
palSetPad(IOPORT1, PIOA_CS_MMC);
mmcObjectInit(&MMCD1);
mmcStart(&MMCD1, &mmccfg);
/*
* Activates the card insertion monitor.
*/
tmr_init(&MMCD1);
/*
* Creates the blinker threads.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and listen for events.
*/
chEvtRegister(&inserted_event, &el0, 0);
chEvtRegister(&removed_event, &el1, 1);
while (TRUE) {
if (!shelltp)
shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);
else if (chThdTerminated(shelltp)) {
chThdRelease(shelltp); /* Recovers memory of the previous shell. */
shelltp = NULL; /* Triggers spawning of a new shell. */
}
chEvtDispatch(evhndl, chEvtWaitOneTimeout(ALL_EVENTS, MS2ST(500)));
}
return 0;
}
