// message handler called by kernel
char accel_msg_handler(void *state, Message *msg)
{
accel_sensor_state_t *s = (accel_sensor_state_t*)state;
switch (msg->type) {
case MSG_INIT:
msg_init(s);
break;
case MSG_FINAL:
msg_final();
break;
default:
return -EINVAL;
}
return SOS_OK;
}
static void
_setup(void)
{
msg_init(FALSE);
g_thread_init(NULL);
syntax_only = FALSE;
debug_flag = TRUE;
verbose_flag = TRUE;
trace_flag = TRUE;
log_msg_registry_init();
test_cfg = cfg_new(0x0308);
g_assert(test_cfg);
const gchar *persist_filename = "";
test_cfg->state = persist_state_new(persist_filename);
_before_test();
}
static int link_mon_peer_list(uint32_t mon_ref)
{
struct nlmsghdr *nlh;
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlattr *nest;
int err = 0;
nlh = msg_init(buf, TIPC_NL_MON_PEER_GET);
if (!nlh) {
fprintf(stderr, "error, message initialisation failed\n");
return -1;
}
nest = mnl_attr_nest_start(nlh, TIPC_NLA_MON);
mnl_attr_put_u32(nlh, TIPC_NLA_MON_REF, mon_ref);
mnl_attr_nest_end(nlh, nest);
err = msg_dumpit(nlh, link_mon_peer_list_cb, NULL);
return err;
}
void ctx_scheduleMessageForReceiverV(HvBase *const _c, const char *name,
const hv_uint32_t timestamp, const char *format, ...) {
va_list ap;
va_start(ap, format);
const int numElem = (int) hv_strlen(format);
HvMessage *m = HV_MESSAGE_ON_STACK(numElem);
msg_init(m, numElem, timestamp);
for (int i = 0; i < numElem; i++) {
switch (format[i]) {
case 'b': msg_setBang(m,i); break;
case 'f': msg_setFloat(m, i, (float) va_arg(ap, double)); break;
case 's': msg_setSymbol(m, i, (char *) va_arg(ap, char *)); break;
default: break;
}
}
_c->f_scheduleMessageForReceiver(_c, name, m);
va_end(ap);
}
struct sk_buff *tipc_disc_init_msg(u32 type,
u32 req_links,
u32 dest_domain,
struct bearer *b_ptr)
{
struct sk_buff *buf = buf_acquire(DSC_H_SIZE);
struct tipc_msg *msg;
if (buf) {
msg = buf_msg(buf);
msg_init(msg, LINK_CONFIG, type, TIPC_OK, DSC_H_SIZE,
dest_domain);
msg_set_non_seq(msg);
msg_set_req_links(msg, req_links);
msg_set_dest_domain(msg, dest_domain);
msg_set_bc_netid(msg, tipc_net_id);
msg_set_media_addr(msg, &b_ptr->publ.addr);
}
return buf;
}
Test::TestResult BloomFilterTestSuite::execTest()
{
std::cout << "Running tests on BloomFilter classes" << std::endl;
msg_init();
msg_setlevel(100);
setupGlobalKey();
std::cout << "Testing BloomFilter..." << std::endl;
testBloomFilter();
std::cout << "Testing AgeBloomFilter..." << std::endl;
testAgeBloomFilter();
std::cout << "Testing CountBloomFilter..." << std::endl;
testCountBloomFilter();
std::cout << "All tests on all BloomFilter classes passed" << std::endl;
return PASSED;
}
void
app_startup(void)
{
main_thread_handle = g_thread_self();
msg_init(FALSE);
iv_set_fatal_msg_handler(app_fatal);
iv_init();
g_thread_init(NULL);
afinter_global_init();
child_manager_init();
dns_cache_init();
alarm_init();
stats_init();
tzset();
log_msg_global_init();
log_tags_init();
log_source_global_init();
log_template_global_init();
}
/*****************************************************************************
* start_cores()
****************************************************************************/
static void start_cores(void)
{
uint32_t core;
/*
* Fire up the packet processing cores
*/
RTE_LCORE_FOREACH_SLAVE(core) {
int index = rte_lcore_index(core);
switch (index) {
case TPG_CORE_IDX_CLI:
assert(false);
break;
case TPG_CORE_IDX_TEST_MGMT:
rte_eal_remote_launch(test_mgmt_loop, NULL, core);
break;
default:
assert(index >= TPG_NR_OF_NON_PACKET_PROCESSING_CORES);
rte_eal_remote_launch(pkt_receive_loop, NULL, core);
}
}
/*
* Wait for packet cores to finish initialization.
*/
RTE_LCORE_FOREACH_SLAVE(core) {
int error;
msg_t msg;
if (!cfg_is_pkt_core(core))
continue;
msg_init(&msg, MSG_PKTLOOP_INIT_WAIT, core, 0);
/* BLOCK waiting for msg to be processed */
error = msg_send(&msg, 0);
if (error)
TPG_ERROR_ABORT("ERROR: Failed to send pktloop init wait msg: %s(%d)!\n",
rte_strerror(-error), -error);
}
}
static int cmd_link_stat_reset(struct nlmsghdr *nlh, const struct cmd *cmd,
struct cmdl *cmdl, void *data)
{
char *link;
char buf[MNL_SOCKET_BUFFER_SIZE];
struct opt *opt;
struct nlattr *nest;
struct opt opts[] = {
{ "link", OPT_KEYVAL, NULL },
{ NULL }
};
if (help_flag) {
(cmd->help)(cmdl);
return -EINVAL;
}
if (parse_opts(opts, cmdl) != 1) {
(cmd->help)(cmdl);
return -EINVAL;
}
nlh = msg_init(buf, TIPC_NL_LINK_RESET_STATS);
if (!nlh) {
fprintf(stderr, "error, message initialisation failed\n");
return -1;
}
opt = get_opt(opts, "link");
if (!opt) {
fprintf(stderr, "error, missing link\n");
return -EINVAL;
}
link = opt->val;
nest = mnl_attr_nest_start(nlh, TIPC_NLA_LINK);
mnl_attr_put_strz(nlh, TIPC_NLA_LINK_NAME, link);
mnl_attr_nest_end(nlh, nest);
return msg_doit(nlh, NULL, NULL);
}
message_t * msg_unpack(uint8_t * packed, uint32_t size)
{
uint32_t i = 0;
uint8_t * pos = packed;
message_t * newmsg = NULL;
tlv_t * cur = NULL;
uint16_t id = 0, length = 0, type = 0;
int ret = 0;
if ((NULL == packed) || (0 == size)) {
return NULL;
}
if (MSG_MAGIC != ntohl(GET32(pos))) {
return NULL;
}
ADVANCE32(pos);
newmsg = msg_init(ntohl(GET32(pos)));
if (NULL == newmsg) {
return NULL;
}
ADVANCE32(pos);
for (i = 0; i < (newmsg->capacity) && (pos - packed < size); i++) {
id = ntohs(GET16(pos)); ADVANCE16(pos);
type = ntohs(GET16(pos)); ADVANCE16(pos);
length = ntohs(GET16(pos)); ADVANCE16(pos);
cur = MSG_TLV(newmsg, i);
ret = unpack_item(type, id, pos, length, cur);
if (0 != ret) {
msg_free(newmsg);
return NULL;
}
pos += length;
}
newmsg->nitems = newmsg->capacity;
return newmsg;
}
static ssize_t
ds1305_nvram_write(struct file *filp, struct kobject *kobj,
struct bin_attribute *attr,
char *buf, loff_t off, size_t count)
{
struct spi_device *spi;
u8 addr;
struct spi_message m;
struct spi_transfer x[2];
int status;
spi = container_of(kobj, struct spi_device, dev.kobj);
addr = (DS1305_WRITE | DS1305_NVRAM) + off;
msg_init(&m, x, &addr, count, buf, NULL);
status = spi_sync(spi, &m);
if (status < 0)
dev_err(&spi->dev, "nvram %s error %d\n", "write", status);
return (status < 0) ? status : count;
}
struct context *
core_start(struct instance *nci)
{
struct context *ctx;
mbuf_init(nci);
msg_init();
conn_init();
ctx = core_ctx_create(nci);
if (ctx != NULL) {
nci->ctx = ctx;
return ctx;
}
conn_deinit();
msg_deinit();
mbuf_deinit();
return NULL;
}
void
app_startup(void)
{
msg_init(FALSE);
iv_set_fatal_msg_handler(app_fatal);
iv_init();
g_thread_init(NULL);
hostname_global_init();
dns_cache_global_init();
dns_cache_thread_init();
afinter_global_init();
child_manager_init();
alarm_init();
stats_init();
tzset();
log_msg_global_init();
log_tags_global_init();
log_source_global_init();
log_template_global_init();
service_management_init();
}
static int disable(struct cmd_struct *cmd, struct arg_struct *arg)
{
int err;
char *bearer;
struct tipc_nl_msg msg;
struct nlattr *attrs;
/* One mandatory (bearer) */
if (arg->argc < arg->loc + 1)
return -EINVAL;
bearer = arg->argv[arg->loc];
msg.nl_flags = NLM_F_REQUEST;
msg.nl_cmd = TIPC_NL_BEARER_DISABLE;
err = msg_init(&msg);
if (err)
return err;
attrs = nla_nest_start(msg.nl_msg, TIPC_NLA_BEARER);
NLA_PUT_STRING(msg.nl_msg, TIPC_NLA_BEARER, bearer);
nla_nest_end(msg.nl_msg, attrs);
err = msg_send(&msg);
if (err)
return err;
err = msg_recv(&msg, NULL);
if (err)
return err;
log_info("Bearer %s disabled\n", bearer);
return 0;
nla_put_failure:
msg_abort(&msg);
return -ENOBUFS;
}
static int get_prop(struct arg_struct *arg, int prop)
{
int err;
struct tipc_nl_msg msg;
struct nlattr *attrs;
char *bearer;
/* One mandatory (bearer) */
if (arg->argc < arg->loc + 1)
return -EINVAL;
bearer = arg->argv[arg->loc];
msg.nl_flags = NLM_F_REQUEST;
msg.nl_cmd = TIPC_NL_BEARER_GET;
msg.callback = &print_prop;
err = msg_init(&msg);
if (err)
return err;
attrs = nla_nest_start(msg.nl_msg, TIPC_NLA_BEARER);
NLA_PUT_STRING(msg.nl_msg, TIPC_NLA_BEARER_NAME, bearer);
nla_nest_end(msg.nl_msg, attrs);
err = msg_send(&msg);
if (err)
return err;
err = msg_recv(&msg, &prop);
if (err)
return err;
return 0;
nla_put_failure:
msg_abort(&msg);
return -ENOBUFS;
}
int main(int argc,char *argv[])
{
char *p_config_name = DEVICECONFIG;
if(argc > 1)
{
p_config_name = argv[1];
}
if(access(p_config_name,F_OK|R_OK) != 0)
{
perror("config file not exist or Limited access!\n");
exit(-1);
}
device_list = create_list(sizeof(DEVCONTEXT),nameCompare);
if(device_list && load_config(p_config_name,device_list) >= 0 && msg_init() > 0)
{
//pthread_create_detached(dev_msg_loop,NULL);
msg_loop();
}
msg_release();
perror("config file is invalid!\n");
return 0;
}
static int list()
{
int err;
struct tipc_nl_msg msg;
msg.nl_flags = NLM_F_REQUEST | NLM_F_DUMP;
msg.nl_cmd = TIPC_NL_MEDIA_GET;
msg.callback = &_list;
err = msg_init(&msg);
if (err)
return err;
err = msg_send(&msg);
if (err)
return err;
err = msg_recv(&msg, NULL);
if (err)
return err;
return 0;
}
void cSlice_onMessage(HvBase *_c, ControlSlice *o, int letIn, const HvMessage *const m,
void (*sendMessage)(HvBase *, int, const HvMessage *const)) {
switch (letIn) {
case 0: {
// if the start point is greater than the number of elements in the source message, do nothing
if (o->i < msg_getNumElements(m)) {
int x = msg_getNumElements(m) - o->i; // number of elements in the new message
if (o->n > 0) x = hv_min_i(x, o->n);
HvMessage *n = HV_MESSAGE_ON_STACK(x);
msg_init(n, x, msg_getTimestamp(m));
hv_memcpy(&n->elem, &m->elem+o->i, x*sizeof(Element));
sendMessage(_c, 0, n);
} else {
// if nothing can be sliced, send a bang out of the right outlet
HvMessage *n = HV_MESSAGE_ON_STACK(1);
msg_initWithBang(n, msg_getTimestamp(m));
sendMessage(_c, 1, n);
}
break;
}
case 1: {
if (msg_isFloat(m,0)) {
o->i = (int) msg_getFloat(m,0);
if (msg_isFloat(m,1)) {
o->n = (int) msg_getFloat(m,1);
}
}
break;
}
case 2: {
if (msg_isFloat(m,0)) {
o->n = (int) msg_getFloat(m,0);
}
break;
}
default: break;
}
}
int msi_answer(MSICall *call, uint8_t capabilities)
{
if (!call || !call->session) {
return -1;
}
MSISession *session = call->session;
LOGGER_DEBUG(session->messenger->log, "Session: %p Answering call from: %u", call->session, call->friend_number);
if (pthread_mutex_trylock(session->mutex) != 0) {
LOGGER_ERROR(session->messenger->log, "Failed to aquire lock on msi mutex");
return -1;
}
if (call->state != msi_CallRequested) {
/* Though sending in invalid state will not cause anything wierd
* Its better to not do it like a maniac */
LOGGER_ERROR(session->messenger->log, "Call is in invalid state!");
pthread_mutex_unlock(session->mutex);
return -1;
}
call->self_capabilities = capabilities;
MSIMessage msg;
msg_init(&msg, requ_push);
msg.capabilities.exists = true;
msg.capabilities.value = capabilities;
send_message(session->messenger, call->friend_number, &msg);
call->state = msi_CallActive;
pthread_mutex_unlock(session->mutex);
return 0;
}
static int cmd_link_mon_summary(struct nlmsghdr *nlh, const struct cmd *cmd,
struct cmdl *cmdl, void *data)
{
char buf[MNL_SOCKET_BUFFER_SIZE];
int err = 0;
if (help_flag) {
fprintf(stderr, "Usage: %s monitor summary\n", cmdl->argv[0]);
return -EINVAL;
}
nlh = msg_init(buf, TIPC_NL_MON_GET);
if (!nlh) {
fprintf(stderr, "error, message initialisation failed\n");
return -1;
}
new_json_obj(json);
err = msg_dumpit(nlh, link_mon_summary_cb, NULL);
delete_json_obj();
return err;
}
static void bclink_send_nack(struct tipc_node *n_ptr)
{
struct sk_buff *buf;
struct tipc_msg *msg;
if (!less(n_ptr->bclink.gap_after, n_ptr->bclink.gap_to))
return;
buf = buf_acquire(INT_H_SIZE);
if (buf) {
msg = buf_msg(buf);
msg_init(msg, BCAST_PROTOCOL, STATE_MSG,
INT_H_SIZE, n_ptr->addr);
msg_set_mc_netid(msg, tipc_net_id);
msg_set_bcast_ack(msg, mod(n_ptr->bclink.last_in));
msg_set_bcgap_after(msg, n_ptr->bclink.gap_after);
msg_set_bcgap_to(msg, n_ptr->bclink.gap_to);
msg_set_bcast_tag(msg, tipc_own_tag);
if (tipc_bearer_send(&bcbearer->bearer, buf, NULL)) {
bcl->stats.sent_nacks++;
buf_discard(buf);
} else {
tipc_bearer_schedule(bcl->b_ptr, bcl);
bcl->proto_msg_queue = buf;
bcl->stats.bearer_congs++;
}
/*
* Ensure we doesn't send another NACK msg to the node
* until 16 more deferred messages arrive from it
* (i.e. helps prevent all nodes from NACK'ing at same time)
*/
n_ptr->bclink.nack_sync = tipc_own_tag;
}
}
void main()
{
int err;
FILE*fp;
msg_init();
sigset_t set;
pthread_t tid1;
pthread_t tid2;
pthread_t tid3;
write_pid_local();
// printf("1\n");
pthread_attr_t attr;
sigemptyset(&set);
sigaddset(&set,SIGUSR1);
sigaddset(&set,SIGUSR2);
err=pthread_sigmask(SIG_BLOCK,&set,NULL);
if(err!=0)
exit(1);
err=pthread_attr_init(&attr);
if(err!=0)
exit(1);
err=pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
if(err==0)
{
err=pthread_create(&tid1,&attr,first_level_recv,NULL);
if(err!=0)
exit(1);
err=pthread_create(&tid2,&attr,second_level_recv,NULL);
if(err!=0)
exit(1);
err=pthread_create(&tid3,&attr,signal_wait,NULL);
if(err!=0)
exit(1);
pthread_attr_destroy(&attr);
}
pthread_exit((void*)1);
}
int main()
{
struct proc *p;
int procs,i;
set_mem('0');
procs = load_progs();
if (procs < 0)
return 1;
if (sched_init() != 0) {
fprintf(stderr, "Scheduler init failed\n");
return 1;
}
msg_init();
for (i=0; i<procs; i++) {
p = &proc_table[i];
/* set up the process */
memset(p, '0', sizeof(struct proc));
p->c = 'F';
p->stack_base = 0;
p->pid = i;
int2word(i*100, p->br);
int2word(99, p->lr);
/* schedule process */
sched_reset(i);
sched_resume(i);
}
/* print_mem(); */
sched_run();
/* print_mem(); */
return 0;
}
int stm32_i2c_msg_write(struct device *dev, struct i2c_msg *msg,
u8_t *next_msg_flags, uint16_t slave)
{
const struct i2c_stm32_config *cfg = DEV_CFG(dev);
I2C_TypeDef *i2c = cfg->i2c;
unsigned int len = 0;
u8_t *buf = msg->buf;
msg_init(dev, msg, next_msg_flags, slave, LL_I2C_REQUEST_WRITE);
len = msg->len;
while (len) {
while (1) {
if (LL_I2C_IsActiveFlag_TXIS(i2c)) {
break;
}
if (LL_I2C_IsActiveFlag_NACK(i2c)) {
goto error;
}
}
LL_I2C_TransmitData8(i2c, *buf);
buf++;
len--;
}
msg_done(dev, msg->flags);
return 0;
error:
LL_I2C_ClearFlag_NACK(i2c);
SYS_LOG_DBG("%s: NACK", __func__);
return -EIO;
}
int main(int argc, char *argv[]) {
int ferr;
TPT_DECL2 (phandle,MAX_SERVERS);
int inx;
int lerr;
int loop = 10;
int max;
int maxsp = 1;
int oid;
int pinx;
MS_SRE sre;
bool verbose = false;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxcp", TA_Int, MAX_CLIENTS, &maxcp },
{ "-maxsp", TA_Int, MAX_SERVERS, &maxsp },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
ferr = msg_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&argc, &argv, msg_debug_hook);
arg_proc_args(zargs, false, argc, argv);
if (maxcp < 0)
maxcp = 1;
if (maxsp < 0)
maxsp = 1;
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
if (!client)
msg_mon_enable_mon_messages(true);
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
TEST_CHK_FEOK(ferr);
// process-wait for clients/servers/shell
ferr = msfs_util_wait_process_count(MS_ProcessType_Generic,
maxcp + maxsp + 1,
NULL,
verbose);
TEST_CHK_FEOK(ferr);
sleep(3); // wait for all process_count's to complete
if (client) {
pinx = atoi(&my_name[4]);
assert(pinx >= 0);
printf("loop=%d\n", loop);
for (inx = 0; inx < loop; inx++) {
for (pinx = 0; pinx < maxsp; pinx++) {
sprintf(serv, "$srv%d", pinx);
ferr = msg_mon_open_process(serv,
TPT_REF2(phandle,pinx),
&oid);
TEST_CHK_FEOK(ferr);
}
for (pinx = 0; pinx < maxsp; pinx++) {
ferr = msg_mon_close_process(TPT_REF2(phandle,pinx));
TEST_CHK_FEOK(ferr);
if (verbose)
printf("%s-close-count=%d\n", my_name, inx);
}
}
} else {
max = 2 * maxcp * loop;
for (inx = 0; inx < max; inx++) {
do {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
ferr = XMSG_READCTRL_(sre.sre_msgId, // msgid
recv_buffer2, // reqctrl
sre.sre_reqCtrlSize); // bytecount
util_check("XMSG_READCTRL_", ferr);
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
sre.sre_reqDataSize); // bytecount
util_check("XMSG_READDATA_", ferr);
XMSG_REPLY_(sre.sre_msgId, // msgid
recv_buffer2, // replyctrl
sre.sre_reqCtrlSize, // replyctrlsize
recv_buffer, // replydata
sre.sre_reqDataSize, // replydatasize
1, // errorclass
NULL); // newphandle
if (verbose)
printf("%s-count=%d\n", my_name, inx);
}
sleep(5);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int stlink2_swim_write_range(programmer_t *pgm, stm8_device_t *device, unsigned char *buffer, unsigned int start, unsigned int length, const memtype_t memtype) {
stlink2_init_session(pgm);
stlink2_write_byte(pgm, 0x00, device->regs.CLK_CKDIVR);
if(memtype == FLASH || memtype == EEPROM || memtype == OPT) {
stlink2_write_and_read_byte(pgm, 0x00, device->regs.FLASH_IAPSR);
}
// Unlock MASS
if(memtype == FLASH) {
stlink2_write_byte(pgm, 0x56, device->regs.FLASH_PUKR);
stlink2_write_byte(pgm, 0xae, device->regs.FLASH_PUKR);
}
if(memtype == EEPROM || memtype == OPT) {
stlink2_write_byte(pgm, 0xae, device->regs.FLASH_DUKR);
stlink2_write_byte(pgm, 0x56, device->regs.FLASH_DUKR);
}
if(memtype == FLASH || memtype == EEPROM || memtype == OPT) {
stlink2_write_and_read_byte(pgm, 0x56, device->regs.FLASH_IAPSR); // mov 0x56, FLASH_IAPSR
}
int i;
int BLOCK_SIZE = device->flash_block_size;
for(i = 0; i < length; i+=BLOCK_SIZE) {
if(memtype == FLASH || memtype == EEPROM) {
// block programming mode
stlink2_write_byte(pgm, 0x01, device->regs.FLASH_CR2); // mov 0x01fe, FLASH_CR2; 0x817e - enable write OPT bytes
if(device->regs.FLASH_NCR2 != 0) { // Device have FLASH_NCR2 register
stlink2_write_byte(pgm, 0xFE, device->regs.FLASH_NCR2);
}
} else if (memtype == OPT){
// option programming mode
stlink2_write_byte(pgm, 0x80, device->regs.FLASH_CR2);
if(device->regs.FLASH_NCR2 != 0) {
stlink2_write_byte(pgm, 0x7F, device->regs.FLASH_NCR2);
}
}
if(memtype == OPT){
int j;
for(j = 0; j < length; j++){
stlink2_write_byte(pgm, buffer[j], start+j);
TRY(8, HI(stlink2_get_status(pgm)) == 1);
}
} else {
// page-based writing
// The first 8 packet bytes are getting transmitted
// with the same USB bulk transfer as the command itself
msg_init(cmd_buf, 0xf40a);
format_int(&(cmd_buf[2]), BLOCK_SIZE, 2, MP_BIG_ENDIAN);
format_int(&(cmd_buf[6]), start + i, 2, MP_BIG_ENDIAN);
memcpy(&(cmd_buf[8]), &(buffer[i]), 8);
msg_send(pgm, cmd_buf, sizeof(cmd_buf));
// Transmitting the rest
msg_send(pgm, &(buffer[i + 8]), BLOCK_SIZE - 8);
// Waiting for the transfer to process
TRY(128, HI(stlink2_get_status(pgm)) == BLOCK_SIZE);
}
if(memtype == FLASH || memtype == EEPROM || memtype == OPT) {
stlink2_wait_until_transfer_completes(pgm, device);
}
}
if(memtype == FLASH || memtype == EEPROM || memtype == OPT) {
stlink2_write_and_read_byte(pgm, 0x56, device->regs.FLASH_IAPSR); // mov 0x56, FLASH_IAPSR
}
stlink2_write_byte(pgm, 0x00, 0x7f80);
stlink2_write_byte(pgm, 0xb6, 0x7f80);
stlink2_finish_session(pgm);
return(length);
}
Test::TestResult ConnectionFilterTestSuite::execTest()
{
std::cout << "running tests on ConnectionFilter" << std::endl;
msg_init();
msg_setlevel(100);
captureDevice = pcap_open_offline("data/connectionfiltertest.pcap", errorBuffer);
if (!captureDevice) {
ERROR(errorBuffer);
}
Packet* p;
ConnectionFilter connFilter(5, 100, 10, 1000);
// first packet is a udp packet
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
// process six packets that come from a connection that did not have any syn packet
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
// process a valid short 5 packets connection
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // SYN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // SYN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == true);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // FIN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // RST
// process a valid connection
// ignore the first syn packet
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // SYN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // SYN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == true);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == true);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == true);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // passed export limit
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false);
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // FIN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // FIN
p = getNextPacket(captureDevice);
REQUIRE(connFilter.processPacket(p) == false); // ACK
pcap_close(captureDevice);
std::cout << "All tests on ConnectionFilter passed" << std::endl;
return PASSED;
}
void handle_init(MSICall *call, const MSIMessage *msg)
{
assert(call);
LOGGER_DEBUG(call->session->messenger->log,
"Session: %p Handling 'init' friend: %d", call->session, call->friend_number);
if (!msg->capabilities.exists) {
LOGGER_WARNING(call->session->messenger->log, "Session: %p Invalid capabilities on 'init'");
call->error = msi_EInvalidMessage;
goto FAILURE;
}
switch (call->state) {
case msi_CallInactive: {
/* Call requested */
call->peer_capabilities = msg->capabilities.value;
call->state = msi_CallRequested;
if (invoke_callback(call, msi_OnInvite) == -1) {
goto FAILURE;
}
}
break;
case msi_CallActive: {
/* If peer sent init while the call is already
* active it's probable that he is trying to
* re-call us while the call is not terminated
* on our side. We can assume that in this case
* we can automatically answer the re-call.
*/
LOGGER_INFO(call->session->messenger->log, "Friend is recalling us");
MSIMessage out_msg;
msg_init(&out_msg, requ_push);
out_msg.capabilities.exists = true;
out_msg.capabilities.value = call->self_capabilities;
send_message(call->session->messenger, call->friend_number, &out_msg);
/* If peer changed capabilities during re-call they will
* be handled accordingly during the next step
*/
}
break;
case msi_CallRequested: // fall-through
case msi_CallRequesting: {
LOGGER_WARNING(call->session->messenger->log, "Session: %p Invalid state on 'init'");
call->error = msi_EInvalidState;
goto FAILURE;
}
}
return;
FAILURE:
send_error(call->session->messenger, call->friend_number, call->error);
kill_call(call);
}
//--------------------------------------------
void msg_mqtt_udp_init(void)
{
msg_init(&queue);
}
extern CDECL int
main(int argc, char **argv)
{
int d;
time_t tmUserStart = time(NULL);
clock_t tmCPUStart = clock();
{
/* FIXME: localtime? */
struct tm * t = localtime(&tmUserStart);
int y = t->tm_year + 1900;
current_days_since_1900 = days_since_1900(y, t->tm_mon + 1, t->tm_mday);
}
/* Always buffer by line for aven's benefit. */
setvbuf(stdout, NULL, _IOLBF, 0);
msg_init(argv);
#if OS_WIN32 || OS_UNIX_MACOSX
pj_set_finder(msg_proj_finder);
#endif
pcs = osnew(settings);
pcs->next = NULL;
pcs->Translate = ((short*) osmalloc(ossizeof(short) * 257)) + 1;
pcs->meta = NULL;
pcs->proj = NULL;
pcs->declination = HUGE_REAL;
pcs->convergence = 0.0;
/* Set up root of prefix hierarchy */
root = osnew(prefix);
root->up = root->right = root->down = NULL;
root->stn = NULL;
root->pos = NULL;
root->ident = NULL;
root->min_export = root->max_export = 0;
root->sflags = BIT(SFLAGS_SURVEY);
root->filename = NULL;
nosurveyhead = NULL;
stnlist = NULL;
cLegs = cStns = cComponents = 0;
totadj = total = totplan = totvert = 0.0;
for (d = 0; d <= 2; d++) {
min[d] = HUGE_REAL;
max[d] = -HUGE_REAL;
pfxHi[d] = pfxLo[d] = NULL;
}
/* at least one argument must be given */
cmdline_init(argc, argv, short_opts, long_opts, NULL, help, 1, -1);
while (1) {
int opt = cmdline_getopt();
if (opt == EOF) break;
switch (opt) {
case 'p':
/* Ignore for compatibility with older versions. */
break;
case 'o': {
osfree(fnm_output_base); /* in case of multiple -o options */
/* can be a directory (in which case use basename of leaf input)
* or a file (in which case just trim the extension off) */
if (fDirectory(optarg)) {
/* this is a little tricky - we need to note the path here,
* and then add the leaf later on (in datain.c) */
fnm_output_base = base_from_fnm(optarg);
fnm_output_base_is_dir = 1;
} else {
fnm_output_base = base_from_fnm(optarg);
}
break;
}
case 'q':
if (fQuiet) fMute = 1;
fQuiet = 1;
break;
case 's':
fSuppress = 1;
break;
case 'v': {
int v = atoi(optarg);
if (v < IMG_VERSION_MIN || v > IMG_VERSION_MAX)
fatalerror(/*3d file format versions %d to %d supported*/88,
IMG_VERSION_MIN, IMG_VERSION_MAX);
img_output_version = v;
break;
}
case 'w':
f_warnings_are_errors = 1;
break;
case 'z': {
/* Control which network optimisations are used (development tool) */
static int first_opt_z = 1;
char c;
if (first_opt_z) {
optimize = 0;
first_opt_z = 0;
}
/* Lollipops, Parallel legs, Iterate mx, Delta* */
while ((c = *optarg++) != '\0')
if (islower((unsigned char)c)) optimize |= BITA(c);
break;
case 1:
fLog = fTrue;
break;
#if OS_WIN32
case 2:
atexit(pause_on_exit);
break;
#endif
}
}
}
if (fLog) {
char *fnm;
if (!fnm_output_base) {
char *p;
p = baseleaf_from_fnm(argv[optind]);
fnm = add_ext(p, EXT_LOG);
osfree(p);
} else if (fnm_output_base_is_dir) {
char *p;
fnm = baseleaf_from_fnm(argv[optind]);
p = use_path(fnm_output_base, fnm);
osfree(fnm);
fnm = add_ext(p, EXT_LOG);
osfree(p);
} else {
fnm = add_ext(fnm_output_base, EXT_LOG);
}
if (!freopen(fnm, "w", stdout))
fatalerror(/*Failed to open output file “%s”*/47, fnm);
osfree(fnm);
}
if (!fMute) {
const char *p = COPYRIGHT_MSG;
puts(PRETTYPACKAGE" "VERSION);
while (1) {
const char *q = p;
p = strstr(p, "(C)");
if (p == NULL) {
puts(q);
break;
}
fwrite(q, 1, p - q, stdout);
fputs(msg(/*©*/0), stdout);
p += 3;
}
}
atexit(delete_output_on_error);
/* end of options, now process data files */
while (argv[optind]) {
const char *fnm = argv[optind];
if (!fExplicitTitle) {
char *lf;
lf = baseleaf_from_fnm(fnm);
if (survey_title) s_catchar(&survey_title, &survey_title_len, ' ');
s_cat(&survey_title, &survey_title_len, lf);
osfree(lf);
}
/* Select defaults settings */
default_all(pcs);
data_file(NULL, fnm); /* first argument is current path */
optind++;
}
validate();
solve_network(/*stnlist*/); /* Find coordinates of all points */
validate();
/* close .3d file */
if (!img_close(pimg)) {
char *fnm = add_ext(fnm_output_base, EXT_SVX_3D);
fatalerror(img_error2msg(img_error()), fnm);
}
if (fhErrStat) safe_fclose(fhErrStat);
out_current_action(msg(/*Calculating statistics*/120));
if (!fMute) do_stats();
if (!fQuiet) {
/* clock() typically wraps after 72 minutes, but there doesn't seem
* to be a better way. Still 72 minutes means some cave!
* We detect if clock() could have wrapped and suppress CPU time
* printing in this case.
*/
double tmUser = difftime(time(NULL), tmUserStart);
double tmCPU;
clock_t now = clock();
#define CLOCK_T_WRAP \
(sizeof(clock_t)<sizeof(long)?(1ul << (CHAR_BIT * sizeof(clock_t))):0)
tmCPU = (now - (unsigned long)tmCPUStart)
/ (double)CLOCKS_PER_SEC;
if (now < tmCPUStart)
tmCPU += CLOCK_T_WRAP / (double)CLOCKS_PER_SEC;
if (tmUser >= tmCPU + CLOCK_T_WRAP / (double)CLOCKS_PER_SEC)
tmCPU = 0;
/* tmUser is integer, tmCPU not - equivalent to (ceil(tmCPU) >= tmUser) */
if (tmCPU + 1 > tmUser) {
printf(msg(/*CPU time used %5.2fs*/140), tmCPU);
} else if (tmCPU == 0) {
if (tmUser != 0.0) {
printf(msg(/*Time used %5.2fs*/141), tmUser);
} else {
fputs(msg(/*Time used unavailable*/142), stdout);
}
} else {
printf(msg(/*Time used %5.2fs (%5.2fs CPU time)*/143), tmUser, tmCPU);
}
putnl();
}
if (msg_warnings || msg_errors) {
if (msg_errors || (f_warnings_are_errors && msg_warnings)) {
printf(msg(/*There were %d warning(s) and %d error(s) - no output files produced.*/113),
msg_warnings, msg_errors);
putnl();
return EXIT_FAILURE;
}
printf(msg(/*There were %d warning(s).*/16), msg_warnings);
putnl();
}
return EXIT_SUCCESS;
}
