END_TEST
START_TEST(test_dbmail_message_store2)
{
DbmailMessage *m, *n;
u64_t physid;
char *t;
char *expect;
m = message_init(broken_message2);
dbmail_message_set_header(m, "Return-Path", dbmail_message_get_header(m, "From"));
expect = dbmail_message_to_string(m);
fail_unless(m != NULL, "dbmail_message_store2 failed");
dbmail_message_store(m);
physid = dbmail_message_get_physid(m);
dbmail_message_free(m);
n = dbmail_message_new();
dbmail_message_set_physid(n, physid);
n = dbmail_message_retrieve(n,physid,DBMAIL_MESSAGE_FILTER_FULL);
fail_unless(n != NULL, "_mime_retrieve failed");
t = dbmail_message_to_string(n);
COMPARE(expect,t);
dbmail_message_free(n);
g_free(expect);
g_free(t);
}
static int module_init(void)
{
int err = 0;
err = mqueue_alloc(&mod_obj.mq, mqueue_handler, &mod_obj);
if (err)
return err;
aufilt_register(&vumeter);
#ifdef USE_NOTIFICATIONS
err = message_init(message_handler, &mod_obj);
if (err)
return err;
#endif
err = cmd_register(cmdv, ARRAY_SIZE(cmdv));
if (err)
return err;
/* start the thread last */
err = pthread_create(&mod_obj.thread, NULL, gtk_thread,
&mod_obj);
if (err)
return err;
return err;
}
static BOOL send_status_message(struct process_id pid)
{
TDB_CONTEXT *tdb;
BOOL ret;
int n_sent = 0;
if (!message_init())
return False;
if (procid_to_pid(&pid) != 0) {
return NT_STATUS_IS_OK(message_send_pid(pid, MSG_USR_STATS,
NULL, 0, False /* duplicates */));
}
tdb = tdb_open_log(lock_path("connections.tdb"), 0,
TDB_DEFAULT, O_RDWR, 0);
if (!tdb) {
fprintf(stderr,"Failed to open connections database"
": %s\n", strerror(errno));
return False;
}
ret = message_send_all(tdb, MSG_USR_STATS, NULL, 0,
False /* duplicates */, &n_sent);
DEBUG(10,("smbcontrol/send_message: broadcast message to "
"%d processes\n", n_sent));
tdb_close(tdb);
return ret;
}
int main(int argc, char **argv)
{
message_init();
lift_pid = fork();
if(!lift_pid) {
lift_process();
}
liftmove_pid = fork();
if(!liftmove_pid){
liftmove_process();
}
int current_person_id = 0;
int j;
for(j = 0; j < MAX_N_PERSONS; j++){
pid_t tmp_pid = fork();
if (tmp_pid == 0){
person_process(current_person_id);
} else{
person_pid[current_person_id] = tmp_pid;
current_person_id ++;
}
}
result_process();
return 0;
}
static BOOL send_message(pid_t pid, int msg_type, const void *buf, int len,
BOOL duplicates)
{
TDB_CONTEXT *tdb;
BOOL ret;
int n_sent = 0;
if (!message_init())
return False;
if (pid != 0)
return message_send_pid(pid, msg_type, buf, len, duplicates);
tdb = tdb_open_log(lock_path("connections.tdb"), 0,
TDB_DEFAULT, O_RDWR, 0);
if (!tdb) {
fprintf(stderr,"Failed to open connections database"
": %s\n", strerror(errno));
return False;
}
ret = message_send_all(tdb,msg_type, buf, len, duplicates,
&n_sent);
DEBUG(10,("smbcontrol/send_message: broadcast message to "
"%d processes\n", n_sent));
tdb_close(tdb);
return ret;
}
int main(int argc, char *argv[])
{
pid_t pid;
int i, n;
static pstring servicesf = CONFIGFILE;
char buf[12];
TimeInit();
setup_logging(argv[0],True);
charset_initialise();
lp_load(servicesf,False,False,False);
message_init();
if (argc != 3) {
fprintf(stderr, "%s: Usage - %s pid count\n", argv[0], argv[0]);
exit(1);
}
pid = atoi(argv[1]);
n = atoi(argv[2]);
message_register(MSG_PONG, pong_message);
for (i=0;i<n;i++) {
message_send_pid(pid, MSG_PING, NULL, 0, True);
}
while (pong_count < i) {
message_dispatch();
msleep(1);
}
/* Now test that the duplicate filtering code works. */
pong_count = 0;
safe_strcpy(buf, "1234567890", sizeof(buf)-1);
for (i=0;i<n;i++) {
message_send_pid(getpid(), MSG_PING, NULL, 0, False);
message_send_pid(getpid(), MSG_PING, buf, 11, False);
}
for (i=0;i<n;i++) {
message_dispatch();
msleep(1);
}
if (pong_count != 2) {
fprintf(stderr, "Duplicate filter failed (%d).\n", pong_count);
exit(1);
}
return (0);
}
static PHP_MINIT_FUNCTION(protobuf) {
map_field_init(TSRMLS_C);
repeated_field_init(TSRMLS_C);
gpb_type_init(TSRMLS_C);
message_init(TSRMLS_C);
descriptor_pool_init(TSRMLS_C);
descriptor_init(TSRMLS_C);
enum_descriptor_init(TSRMLS_C);
util_init(TSRMLS_C);
}
int webapp_chat_init(void)
{
int err = 0;
err = message_init(message_handler, NULL);
if (err)
return err;
err = odict_alloc(&messages, DICT_BSIZE);
return err;
}
END_TEST
START_TEST(test_dbmail_message_to_string)
{
char *result;
DbmailMessage *m;
m = message_init(multipart_message);
result = dbmail_message_to_string(m);
COMPARE(multipart_message, result);
g_free(result);
dbmail_message_free(m);
//
m = message_init(simple_with_from);
result = dbmail_message_to_string(m);
COMPARE(simple_with_from, result);
g_free(result);
dbmail_message_free(m);
}
int main(int argc, char** argv) {
struct timeval start, end;
uint32_t time;
int i;
if (argc != 3) {
printf("Usage: ./client thread_num policy_num\n");
exit(1);
}
g_thread_num = atoi(argv[1]);
g_policy_num = atoi(argv[2]);
if (policy_init() < 0) {
printf("policy init failed\n");
exit(1);
}
init_coding();
message_init();
if (g_thread_num > 0) {
pthread_t* tid = (pthread_t*)malloc(sizeof(pthread_t) * g_thread_num);
struct work* w = (struct work*)malloc(sizeof(struct work) * g_thread_num);
gettimeofday(&start, NULL);
for (i = 0; i < g_thread_num; i++) {
w[i].start = i * (g_policy_num / g_thread_num);
w[i].end = (i + 1) * (g_policy_num / g_thread_num);
w[i].end = w[i].end > g_policy_num ? g_policy_num : w[i].end;
pthread_create(tid + i, NULL, PushRules, w + i);
}
for (i = 0; i < g_thread_num; i++) {
pthread_join(tid[i], NULL);
}
gettimeofday(&end, NULL);
} else {
struct work w;
gettimeofday(&start, NULL);
w.start = 0;
w.end = g_policy_num;
PushRules(&w);
gettimeofday(&end, NULL);
}
time = 1000000 * (end.tv_sec - start.tv_sec) + (end.tv_usec - start.tv_usec);
printf("policy num %d, time %fms\n", g_policy_num, time / 1000.0);
return 0;
}
void network_announce_ourselves(struct uloop_timeout *timer)
{
// TODO: Generate announce message.
message_t msg;
message_init(&msg);
network_send_message(&msg);
message_free(&msg);
// Reschedule timer if no peer selected.
if (net_status.peer == NULL) {
uloop_timeout_set(timer, KORUZA_ANNOUNCE_INTERVAL);
}
}
/*
lock the secrets tdb based on a string - this is used as a primitive form of mutex
between smbd instances.
*/
BOOL secrets_named_mutex(const char *name, unsigned int timeout)
{
int ret;
if (!message_init())
return False;
ret = tdb_lock_bystring(tdb, name, timeout);
if (ret == 0)
DEBUG(10,("secrets_named_mutex: got mutex for %s\n", name ));
return (ret == 0);
}
void handle_init(void) {
status_bar_init();
#ifdef PBL_ROUND
round_bottom_bar_init();
#endif
settings_init();
locale_init();
stations_init();
favorites_init();
message_init();
ui_push_window(new_window_main_menu());
}
// kill -HUP `ps -ef | awk '$8 ~ /a\.out/ { print $2 }'`
int
main(int argc, char *argv[])
{
if (argc > 1)
message_init(argv[1], NULL);
else
message_init(NULL, NULL);
message_thread_init(NULL);
//mc_file = message_get_category("log");
#if 0
mc_stdout = message_file_category("stdout", "/dev/stdout");
mc_file = message_file_category("file", "msg.out");
mc_sink = message_multiplex_category("multiplex",
mc_stdout, mc_file, MC_DEFAULT, NULL);
mc_sink->fmt_prologue = strdup("[%P:%h] (%t) ");
mc_sink->fmt_time = strdup("%FT%T");
m_info("hello");
test_multiplex();
#endif /* 0 */
mc_mux = message_get_category("multi");
#if 1
m_info("before multithreads..");
test_multithreads("log");
m_info("after multithreads..");
#endif /* 0 */
//benchmark(mc_file);
message_unget_category(mc_mux);
return 0;
}
int main(int argc, char **argv) {
message_init();
gettimeofday(&tm_main_start, 0);
tm_main_total.tv_sec = 0;
test_ophcrack_preload_all0();
test_ophcrack_preload_all1();
test_ophcrack_preload_all2();
test_ophcrack_preload_all3();
test_ophcrack_preload_all4();
test_ophcrack_preload_all5();
test_ophcrack_preload_all6();
test_ophcrack_preload_all7();
return 0;
}
END_TEST
//DbmailMessage * dbmail_message_init_with_string(DbmailMessage *self, const GString *content);
START_TEST(test_dbmail_message_init_with_string)
{
DbmailMessage *m;
GTuples *t;
m = message_init(multipart_message);
t = g_relation_select(m->headers, "Received", 0);
fail_unless(t->len==2,"Too few or too many headers in tuple [%d]\n", t->len);
g_tuples_destroy(t);
dbmail_message_free(m);
// m = message_init(simple_message_part);
// fail_unless(dbmail_message_get_class(m)==DBMAIL_MESSAGE_PART, "init_with string failed");
// dbmail_message_free(m);
}
//-----------------------------------------------------------------------------
// Create the message array. During the running of the daemon we should assume
// that this array exists. So we will create it, and pre-fill it with a number
// of empty message objects.
static void init_msglist(system_data_t *sysdata)
{
int i;
assert(sysdata);
assert(sysdata->msg_list == NULL);
sysdata->msg_list = (message_t **) malloc(sizeof(message_t *) * 10);
assert(sysdata->msg_list);
sysdata->msg_max = 10;
sysdata->msg_next = 0;
sysdata->msg_used = 0;
for (i=0; i<10; i++) {
sysdata->msg_list[i] = (message_t *) malloc(sizeof(message_t));
assert(sysdata->msg_list[i]);
message_init(sysdata->msg_list[i], i);
}
}
int main(int argc, char **argv) {
message_init();
si_ui_init(); // Initialize user interface. (Must be done here!)
lift_pid = fork();
if(!lift_pid) {
lift_process();
}
uidraw_pid = fork();
if(!uidraw_pid) {
uidraw_process();
}
liftmove_pid = fork();
if(!liftmove_pid) {
liftmove_process();
}
uicommand_process();
return 0;
}
int main(int argc, char **argv) {
int i;
int current_person_id = 0;
int pid;
printf("Length of time_msg: %lld \n", sizeof(struct long_time_msg));
message_init();
si_ui_init(); // Initialize user interface. (Must be done here!)
lift_pid = fork();
if(!lift_pid) {
lift_process();
}
uidraw_pid = fork();
if(!uidraw_pid) {
uidraw_process();
}
liftmove_pid = fork();
if(!liftmove_pid) {
liftmove_process();
}
guard_pid = fork();
if(!guard_pid) {
file_guard_process();
}
for (i=0; i<MAX_N_PERSONS; i++) {
if (current_person_id < MAX_N_PERSONS) {
pid = fork();
if (!pid) {
person_process(current_person_id);
} else {
person_pid[current_person_id++] = pid;
}
}
}
uicommand_process();
return 0;
}
int main( void )
{
vidid.pid = VIDEO;
mainid.pid = MAIN;
hackid.pid = 4;
clear_screen( );
disable_interrupts( );
//initialize_timer_frequency( );
initialize_keyboardISR( );
initialize_timerISR( );
print_at( trace_counter++, TRACE_COLUMN, "Timer initialized", COLOR );
message_init( );
print_at( trace_counter++, TRACE_COLUMN, "Messages initialized", COLOR );
if( xthread_create( vidid, run_video ) ) {
print_at( trace_counter++, TRACE_COLUMN, "Failed to create video thread", COLOR );
}
else {
print_at( trace_counter++, TRACE_COLUMN, "Created video thread", COLOR );
}
if( xthread_create( mainid, main_thread ) ) {
print_at( trace_counter++, TRACE_COLUMN, "Failed to create main thread", COLOR );
}
else {
print_at( trace_counter++, TRACE_COLUMN, "Created test thread", COLOR );
}
enable_interrupts( );
print_at( trace_counter++, TRACE_COLUMN, "Looping in main", COLOR );
for ( ;; ) { }
print_at( trace_counter++, TRACE_COLUMN, "SHOULD NEVER SEE THIS!", COLOR );
return 0;
}
/*
* Take the data out of the passed ghost file and toss it into
* a dynamically allocated message structure.
*/
static void
makemessage(FILE *f, int omsgCount, int nmsgCount)
{
size_t size;
struct message *omessage; /* old message structure array */
struct message *nmessage;
omessage = get_abs_message(1);
size = (nmsgCount + 1) * sizeof(*nmessage);
nmessage = realloc(omessage, size);
if (nmessage == NULL)
err(EXIT_FAILURE,
"Insufficient memory for %d messages", nmsgCount);
if (omsgCount == 0 || omessage == NULL)
dot = nmessage;
else
dot = nmessage + (dot - omessage);
thread_fix_old_links(nmessage, omessage, omsgCount);
#ifndef THREAD_SUPPORT
message = nmessage;
#endif
size -= (omsgCount + 1) * sizeof(*nmessage);
(void)fflush(f);
(void)lseek(fileno(f), (off_t)sizeof(*nmessage), SEEK_SET);
if (read(fileno(f), &nmessage[omsgCount], size) != (ssize_t)size)
errx(EXIT_FAILURE, "Message temporary file corrupted");
message_init(&nmessage[nmsgCount], (off_t)0, 0); /* append a dummy */
thread_fix_new_links(nmessage, omsgCount, nmsgCount);
(void)Fclose(f);
}
static int osrfHttpTranslatorProcess(osrfHttpTranslator* trans) {
if(trans->body == NULL)
return HTTP_BAD_REQUEST;
if(!osrfHttpTranslatorSetTo(trans))
return HTTP_BAD_REQUEST;
char* jsonBody = osrfHttpTranslatorParseRequest(trans);
if (NULL == jsonBody)
return HTTP_BAD_REQUEST;
while(client_recv(trans->handle, 0))
continue; // discard any old status messages in the recv queue
// send the message to the recipient
transport_message* tmsg = message_init(
jsonBody, NULL, trans->thread, trans->recipient, NULL);
message_set_osrf_xid(tmsg, osrfLogGetXid());
client_send_message(trans->handle, tmsg);
message_free(tmsg);
free(jsonBody);
if(trans->disconnectOnly) {
osrfLogDebug(OSRF_LOG_MARK, "exiting early on disconnect");
osrfCacheRemove(trans->thread);
return OK;
}
// process the response from the opensrf service
int firstWrite = 1;
while(!trans->complete) {
transport_message* msg = client_recv(trans->handle, trans->timeout);
if(trans->handle->error) {
osrfLogError(OSRF_LOG_MARK, "Transport error");
osrfCacheRemove(trans->thread);
return HTTP_INTERNAL_SERVER_ERROR;
}
if(msg == NULL)
return HTTP_GATEWAY_TIME_OUT;
if(msg->is_error) {
osrfLogError(OSRF_LOG_MARK, "XMPP message resulted in error code %d", msg->error_code);
osrfCacheRemove(trans->thread);
return HTTP_NOT_FOUND;
}
if(!osrfHttpTranslatorCheckStatus(trans, msg))
continue;
if(firstWrite) {
osrfHttpTranslatorInitHeaders(trans, msg);
if(trans->connecting)
osrfHttpTranslatorCacheSession(trans, msg->sender);
firstWrite = 0;
}
if(trans->multipart) {
osrfHttpTranslatorWriteChunk(trans, msg);
if(trans->connectOnly)
break;
} else {
if(!trans->messages)
trans->messages = osrfNewList();
osrfListPush(trans->messages, msg->body);
if(trans->complete || trans->connectOnly) {
growing_buffer* buf = buffer_init(128);
unsigned int i;
OSRF_BUFFER_ADD(buf, osrfListGetIndex(trans->messages, 0));
for(i = 1; i < trans->messages->size; i++) {
buffer_chomp(buf); // chomp off the closing array bracket
char* body = osrfListGetIndex(trans->messages, i);
char newbuf[strlen(body)];
sprintf(newbuf, "%s", body+1); // chomp off the opening array bracket
OSRF_BUFFER_ADD_CHAR(buf, ',');
OSRF_BUFFER_ADD(buf, newbuf);
}
ap_rputs(buf->buf, trans->apreq);
buffer_free(buf);
}
}
}
if(trans->disconnecting) // DISCONNECT within a multi-message batch
osrfCacheRemove(trans->thread);
return OK;
}
int main(int argc, char **argv) {
sudo(argc, argv);
message_init(*argv);
const char *optstring = "qh";
static struct option longopts[] = {
{"quiet", 0, 0, 0},
{"help", 0, 0, 0},
{0, 0, 0, 0}
};
int c = -1, longindex = 0;
while (-1 != (c = getopt_long(
argc, argv, optstring, longopts, &longindex
))) {
switch (c) {
case 0:
switch (longindex) {
case 0: /* --quiet */
message_quiet_default(1);
message_quiet(1);
break;
case 1: /* --help */
usage(*argv);
help();
exit(0);
}
break;
case 'q': /* -q */
message_quiet_default(1);
message_quiet(1);
break;
case 'h': /* -h */
usage(*argv);
help();
exit(0);
break;
case '?':
usage(*argv);
exit(1);
break;
}
}
char *name;
switch (argc - optind) {
case 1:
name = argv[optind];
break;
default:
usage(*argv);
exit(1);
break;
}
if (!sandbox_valid(name)) {
message_loud("invalid sandbox name %s\n", name);
exit(1);
}
int result = sandbox_destroy(name);
message_free();
return result;
}
static void initialise_ui(void)
{
GFont bigNumbers, ltlNumbers, regText, bigText;
s_window = window_create();
window_set_background_color(s_window, GColorWhite);
#ifndef PBL_SDK_3
window_set_fullscreen(s_window, true);
#endif
//-- colors --
s_colors = (struct TCColors*)malloc(sizeof(struct TCColors));
s_colors->font_color_pri = BLU;
s_colors->font_color_sec = GColorBlack;
s_colors->font_color_ter = GColorBlack;
//-- load font resources --
s_res_sqr_num = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SQUARENUM_64));
s_res_sqr_num_32 = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SQUARENUM_32));
s_res_scp = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SCP_12));
s_res_scp_20 = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_SCP_20));
bigNumbers = s_res_sqr_num;
ltlNumbers = s_res_sqr_num_32;
regText = s_res_scp;
bigText = s_res_scp_20;
//-- load image resources --
s_res_w01d = gbitmap_create_with_resource(RESOURCE_ID_w01d);
s_res_w01n = gbitmap_create_with_resource(RESOURCE_ID_w01n);
s_res_w02d = gbitmap_create_with_resource(RESOURCE_ID_w02d);
s_res_w02n = gbitmap_create_with_resource(RESOURCE_ID_w02n);
s_res_w03d = gbitmap_create_with_resource(RESOURCE_ID_w03d);
s_res_w04d = gbitmap_create_with_resource(RESOURCE_ID_w04d);
s_res_w09d = gbitmap_create_with_resource(RESOURCE_ID_w09d);
s_res_w10d = gbitmap_create_with_resource(RESOURCE_ID_w10d);
s_res_w10n = gbitmap_create_with_resource(RESOURCE_ID_w10n);
s_res_w11d = gbitmap_create_with_resource(RESOURCE_ID_w11d);
s_res_w13d = gbitmap_create_with_resource(RESOURCE_ID_w13d);
s_res_w50d = gbitmap_create_with_resource(RESOURCE_ID_w50d);
s_res_bluetooth = gbitmap_create_with_resource(RESOURCE_ID_bluetooth_icon);
s_res_bluetoothOff = gbitmap_create_with_resource(RESOURCE_ID_bluetooth_off);
//-- text layers --
// s_time_hr
s_time_hr = text_layer_create(GRect(40, -10, 50, 90));
text_layer_set_background_color(s_time_hr, GColorClear);
text_layer_set_text_color(s_time_hr, s_colors->font_color_pri);
text_layer_set_text_alignment(s_time_hr, GTextAlignmentRight);
text_layer_set_font(s_time_hr, bigNumbers);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_time_hr);
// s_time_hr2
s_time_hr2 = text_layer_create(GRect(40, -10, 100, 90));
text_layer_set_background_color(s_time_hr2, GColorClear);
text_layer_set_text_color(s_time_hr2, s_colors->font_color_pri);
text_layer_set_text_alignment(s_time_hr2, GTextAlignmentRight);
text_layer_set_font(s_time_hr2, bigNumbers);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_time_hr2);
// s_time_min
s_time_min = text_layer_create(GRect(40, 43, 50, 90));
text_layer_set_background_color(s_time_min, GColorClear);
text_layer_set_text_color(s_time_min, s_colors->font_color_pri);
text_layer_set_text_alignment(s_time_min, GTextAlignmentRight);
text_layer_set_font(s_time_min, bigNumbers);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_time_min);
// s_time_min2
s_time_min2 = text_layer_create(GRect(40, 43, 100, 90));
text_layer_set_background_color(s_time_min2, GColorClear);
text_layer_set_text_color(s_time_min2, s_colors->font_color_pri);
text_layer_set_text_alignment(s_time_min2, GTextAlignmentRight);
text_layer_set_font(s_time_min2, bigNumbers);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_time_min2);
// s_weather_temp
s_weather_temp = text_layer_create(GRect(-2, 30, 46, 27));
text_layer_set_background_color(s_weather_temp, GColorClear);
text_layer_set_text_color(s_weather_temp, s_colors->font_color_pri);
text_layer_set_text_alignment(s_weather_temp, GTextAlignmentCenter);
text_layer_set_font(s_weather_temp, bigText);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_weather_temp);
// s_date_year = first part of a year (20)
s_date_year = text_layer_create(GRect(42, 130, 46, 37));
text_layer_set_background_color(s_date_year, GColorClear);
text_layer_set_text_color(s_date_year, s_colors->font_color_sec);
text_layer_set_text_alignment(s_date_year, GTextAlignmentRight);
text_layer_set_font(s_date_year, ltlNumbers);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_date_year);
// s_date_year2 = last part of a year (15)
s_date_year2 = text_layer_create(GRect(93, 130, 46, 37));
text_layer_set_background_color(s_date_year2, GColorClear);
text_layer_set_text_color(s_date_year2, s_colors->font_color_sec);
text_layer_set_text_alignment(s_date_year2, GTextAlignmentRight);
text_layer_set_font(s_date_year2, ltlNumbers);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_date_year2);
// s_date_day = 01, 02, 03, ..., 31
s_date_day = text_layer_create(GRect(93, 105, 46, 37));
text_layer_set_background_color(s_date_day, GColorClear);
text_layer_set_text_color(s_date_day, s_colors->font_color_sec);
text_layer_set_text_alignment(s_date_day, GTextAlignmentRight);
text_layer_set_font(s_date_day, ltlNumbers);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_date_day);
// s_date_month = 01, 02, 03, ..., 12
s_date_month = text_layer_create(GRect(42, 105, 46, 37));
text_layer_set_background_color(s_date_month, GColorClear);
text_layer_set_text_color(s_date_month, s_colors->font_color_sec);
text_layer_set_text_alignment(s_date_month, GTextAlignmentRight);
text_layer_set_font(s_date_month, ltlNumbers);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_date_month);
/* looks ugly
// s_day_h = horizontal day listing
s_day_h = text_layer_create(GRect(0, 112, 46, 37));
text_layer_set_background_color(s_day_h, GColorClear);
text_layer_set_text_color(s_day_h, s_colors->font_color_pri);
text_layer_set_text_alignment(s_day_h, GTextAlignmentRight);
text_layer_set_font(s_day_h, bigText);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_day_h);
// s_month_h = horizontal month listing
s_month_h = text_layer_create(GRect(0, 135, 46, 37));
text_layer_set_background_color(s_month_h, GColorClear);
text_layer_set_text_color(s_month_h, s_colors->font_color_pri);
text_layer_set_text_alignment(s_month_h, GTextAlignmentRight);
text_layer_set_font(s_month_h, bigText);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_month_h);
*/
// s_ampm
s_ampm = text_layer_create(GRect(50, -4, 14, 13));
text_layer_set_background_color(s_ampm, GColorClear);
text_layer_set_text_color(s_ampm, s_colors->font_color_ter);
text_layer_set_font(s_ampm, regText);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_ampm);
// s_day_v = vertical day listing
s_day_v = text_layer_create(GRect(40, 7, 8, 36));
text_layer_set_background_color(s_day_v, GColorClear);
text_layer_set_text_color(s_day_v, s_colors->font_color_ter);
text_layer_set_text_alignment(s_day_v, GTextAlignmentCenter);
text_layer_set_font(s_day_v, regText);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_day_v);
// s_date_day_v = same as s_date_day, but vertical, below s_day
s_date_day_v = text_layer_create(GRect(40, 48, 8, 24));
text_layer_set_background_color(s_date_day_v, GColorClear);
text_layer_set_text_color(s_date_day_v, s_colors->font_color_ter);
text_layer_set_text_alignment(s_date_day_v, GTextAlignmentCenter);
text_layer_set_font(s_date_day_v, regText);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_date_day_v);
// s_month_v = vertical month listing
s_month_v = text_layer_create(GRect(40, 75, 8, 36));
text_layer_set_background_color(s_month_v, GColorClear);
text_layer_set_text_color(s_month_v, s_colors->font_color_ter);
text_layer_set_text_alignment(s_month_v, GTextAlignmentCenter);
text_layer_set_font(s_month_v, regText);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_month_v);
// s_year_v = vertical year listing
s_year_v = text_layer_create(GRect(40, 115, 8, 48));
text_layer_set_background_color(s_year_v, GColorClear);
text_layer_set_text_color(s_year_v, s_colors->font_color_ter);
text_layer_set_text_alignment(s_year_v, GTextAlignmentCenter);
text_layer_set_font(s_year_v, regText);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_year_v);
// s_battery
s_battery = text_layer_create(GRect(101, -4, 36, 13));
text_layer_set_background_color(s_battery, GColorClear);
text_layer_set_text_color(s_battery, s_colors->font_color_ter);
text_layer_set_font(s_battery, regText);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_battery);
//-- bitmaps --
// s_weather_image
s_weather_image = bitmap_layer_create(GRect(0, -3, 40, 40));
bitmap_layer_set_compositing_mode(s_weather_image, GCompOpSet);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_weather_image);
// s_bluetooth_image
s_bluetooth_image = bitmap_layer_create(GRect(83, -3, 20, 20));
bitmap_layer_set_compositing_mode(s_bluetooth_image, GCompOpSet);
layer_add_child(window_get_root_layer(s_window), (Layer *)s_bluetooth_image);
//-- subscribing to events --
tick_timer_service_subscribe(MINUTE_UNIT, time_handler);
battery_state_service_subscribe(battery_handler);
message_init(s_weather_temp); // start weather service
bluetooth_connection_service_subscribe(bluetooth_handler);
//-- setting face --
update_all();
}
void main(void) {
bit test_radio = 0;
bit bounce_radio = 0;
/* Initialize app modules. Not reinitialized upon reset. */
message_init();
compose_init();
inbox_init();
info_init();
reset:
sleepy_ = 0;
state_ = STATE_VIEW;
if (bounce_radio) {
repeater_mode();
}
/* Initialize system modules. */
clock_init();
setIOPorts();
configureSPI();
LCDReset();
radio_init();
random_init();
inbox_draw();
if (test_radio) {
run_test_radio();
}
/* Main loop. */
radio_listen();
while (1) {
poll_keyboard();
/* Send and receive messages. */
message_tick();
/* Handle background tasks (like progress bar) */
if (compose_tick() && state_ == STATE_COMPOSE) {
compose_draw();
}
if (info_tick() && state_ == STATE_INFO) {
info_draw();
}
/* go to sleep (more or less a shutdown) if power button pressed */
if (sleepy_) {
clear();
clock_delayms(1000);
SSN = LOW;
LCDPowerSave();
SSN = HIGH;
sleep();
/* reset on wake */
goto reset;
}
}
}
/**
@brief React to the closing of an XML tag.
@param session Pointer to a transport_session, cast to a void pointer.
@param name Pointer to the name of the tag that is closing.
See what kind of tag is closing, and respond accordingly.
*/
static void endElementHandler( void *session, const xmlChar *name) {
transport_session* ses = (transport_session*) session;
if( ! ses ) { return; }
// Bypass a level of indirection, since we'll examine the machine repeatedly:
jabber_machine* machine = ses->state_machine;
if( machine->in_message && strcmp( (char*) name, "message" ) == 0 ) {
/* pass off the message info the callback */
if( ses->message_callback ) {
transport_message* msg = message_init(
OSRF_BUFFER_C_STR( ses->body_buffer ),
OSRF_BUFFER_C_STR( ses->subject_buffer ),
OSRF_BUFFER_C_STR( ses->thread_buffer ),
OSRF_BUFFER_C_STR( ses->recipient_buffer ),
OSRF_BUFFER_C_STR( ses->from_buffer ) );
message_set_router_info( msg,
ses->router_from_buffer->buf,
ses->router_to_buffer->buf,
ses->router_class_buffer->buf,
ses->router_command_buffer->buf,
ses->router_broadcast );
message_set_osrf_xid( msg, ses->osrf_xid_buffer->buf );
if( ses->message_error_type->n_used > 0 ) {
set_msg_error( msg, ses->message_error_type->buf, ses->message_error_code );
}
if( msg == NULL ) { return; }
ses->message_callback( ses->user_data, msg );
}
machine->in_message = 0;
reset_session_buffers( session );
return;
}
if( machine->in_message_body && strcmp( (const char*) name, "body" ) == 0 ) {
machine->in_message_body = 0;
return;
}
if( machine->in_subject && strcmp( (const char*) name, "subject" ) == 0 ) {
machine->in_subject = 0;
return;
}
if( machine->in_thread && strcmp( (const char*) name, "thread" ) == 0 ) {
machine->in_thread = 0;
return;
}
if( machine->in_iq && strcmp( (const char*) name, "iq" ) == 0 ) {
machine->in_iq = 0;
if( ses->message_error_code > 0 ) {
if( 401 == ses->message_error_code )
osrfLogWarning( OSRF_LOG_MARK, "Error 401 in IQ packet: not authorized" );
else
osrfLogWarning( OSRF_LOG_MARK, "Error in IQ packet: code %d",
ses->message_error_code );
}
reset_session_buffers( session );
return;
}
if( machine->in_presence && strcmp( (const char*) name, "presence" ) == 0 ) {
machine->in_presence = 0;
/*
if( ses->presence_callback ) {
// call the callback with the status, etc.
}
*/
reset_session_buffers( session );
return;
}
if( machine->in_status && strcmp( (const char*) name, "status" ) == 0 ) {
machine->in_status = 0;
return;
}
if( machine->in_message_error && strcmp( (const char*) name, "error" ) == 0 ) {
machine->in_message_error = 0;
return;
}
if( machine->in_error && strcmp( (const char*) name, "stream:error" ) == 0 ) {
machine->in_error = 0;
return;
}
}
/**************************************************************************** **
main program
**************************************************************************** */
int main(int argc, const char *argv[])
{
pstring logfile;
static BOOL opt_interactive;
poptContext pc;
static char *p_lmhosts = dyn_LMHOSTSFILE;
static BOOL no_process_group = False;
struct poptOption long_options[] = {
POPT_AUTOHELP
{"daemon", 'D', POPT_ARG_VAL, &is_daemon, True, "Become a daemon(default)" },
{"interactive", 'i', POPT_ARG_VAL, &opt_interactive, True, "Run interactive (not a daemon)" },
{"foreground", 'F', POPT_ARG_VAL, &Fork, False, "Run daemon in foreground (for daemontools & etc)" },
{"no-process-group", 0, POPT_ARG_VAL, &no_process_group, True, "Don't create a new process group" },
{"log-stdout", 'S', POPT_ARG_VAL, &log_stdout, True, "Log to stdout" },
{"hosts", 'H', POPT_ARG_STRING, &p_lmhosts, 'H', "Load a netbios hosts file"},
{"port", 'p', POPT_ARG_INT, &global_nmb_port, NMB_PORT, "Listen on the specified port" },
POPT_COMMON_SAMBA
{ NULL }
};
load_case_tables();
global_nmb_port = NMB_PORT;
pc = poptGetContext("nmbd", argc, argv, long_options, 0);
while (poptGetNextOpt(pc) != -1) {};
poptFreeContext(pc);
global_in_nmbd = True;
StartupTime = time(NULL);
sys_srandom(time(NULL) ^ sys_getpid());
if (!override_logfile) {
slprintf(logfile, sizeof(logfile)-1, "%s/log.nmbd", dyn_LOGFILEBASE);
lp_set_logfile(logfile);
}
fault_setup((void (*)(void *))fault_continue );
dump_core_setup("nmbd");
/* POSIX demands that signals are inherited. If the invoking process has
* these signals masked, we will have problems, as we won't receive them. */
BlockSignals(False, SIGHUP);
BlockSignals(False, SIGUSR1);
BlockSignals(False, SIGTERM);
CatchSignal( SIGHUP, SIGNAL_CAST sig_hup );
CatchSignal( SIGTERM, SIGNAL_CAST sig_term );
#if defined(SIGFPE)
/* we are never interested in SIGFPE */
BlockSignals(True,SIGFPE);
#endif
/* We no longer use USR2... */
#if defined(SIGUSR2)
BlockSignals(True, SIGUSR2);
#endif
if ( opt_interactive ) {
Fork = False;
log_stdout = True;
}
if ( log_stdout && Fork ) {
DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
exit(1);
}
setup_logging( argv[0], log_stdout );
reopen_logs();
DEBUG( 0, ( "Netbios nameserver version %s started.\n", SAMBA_VERSION_STRING) );
DEBUGADD( 0, ( "%s\n", COPYRIGHT_STARTUP_MESSAGE ) );
if ( !reload_nmbd_services(False) )
return(-1);
if(!init_names())
return -1;
reload_nmbd_services( True );
if (strequal(lp_workgroup(),"*")) {
DEBUG(0,("ERROR: a workgroup name of * is no longer supported\n"));
exit(1);
}
set_samba_nb_type();
if (!is_daemon && !is_a_socket(0)) {
DEBUG(0,("standard input is not a socket, assuming -D option\n"));
is_daemon = True;
}
if (is_daemon && !opt_interactive) {
DEBUG( 2, ( "Becoming a daemon.\n" ) );
become_daemon(Fork, no_process_group);
}
#if HAVE_SETPGID
/*
* If we're interactive we want to set our own process group for
* signal management.
*/
if (opt_interactive && !no_process_group)
setpgid( (pid_t)0, (pid_t)0 );
#endif
#ifndef SYNC_DNS
/* Setup the async dns. We do it here so it doesn't have all the other
stuff initialised and thus chewing memory and sockets */
if(lp_we_are_a_wins_server() && lp_dns_proxy()) {
start_async_dns();
}
#endif
if (!directory_exist(lp_lockdir(), NULL)) {
mkdir(lp_lockdir(), 0755);
}
pidfile_create("nmbd");
message_init();
message_register(MSG_FORCE_ELECTION, nmbd_message_election, NULL);
#if 0
/* Until winsrepl is done. */
message_register(MSG_WINS_NEW_ENTRY, nmbd_wins_new_entry, NULL);
#endif
message_register(MSG_SHUTDOWN, nmbd_terminate, NULL);
message_register(MSG_SMB_CONF_UPDATED, msg_reload_nmbd_services, NULL);
message_register(MSG_SEND_PACKET, msg_nmbd_send_packet, NULL);
TimeInit();
DEBUG( 3, ( "Opening sockets %d\n", global_nmb_port ) );
if ( !open_sockets( is_daemon, global_nmb_port ) ) {
kill_async_dns_child();
return 1;
}
/* Determine all the IP addresses we have. */
load_interfaces();
/* Create an nmbd subnet record for each of the above. */
if( False == create_subnets() ) {
DEBUG(0,("ERROR: Failed when creating subnet lists. Exiting.\n"));
kill_async_dns_child();
exit(1);
}
/* Load in any static local names. */
load_lmhosts_file(p_lmhosts);
DEBUG(3,("Loaded hosts file %s\n", p_lmhosts));
/* If we are acting as a WINS server, initialise data structures. */
if( !initialise_wins() ) {
DEBUG( 0, ( "nmbd: Failed when initialising WINS server.\n" ) );
kill_async_dns_child();
exit(1);
}
/*
* Register nmbd primary workgroup and nmbd names on all
* the broadcast subnets, and on the WINS server (if specified).
* Also initiate the startup of our primary workgroup (start
* elections if we are setup as being able to be a local
* master browser.
*/
if( False == register_my_workgroup_and_names() ) {
DEBUG(0,("ERROR: Failed when creating my my workgroup. Exiting.\n"));
kill_async_dns_child();
exit(1);
}
/* We can only take signals in the select. */
BlockSignals( True, SIGTERM );
process();
if (dbf)
x_fclose(dbf);
kill_async_dns_child();
return(0);
}
int main (int argc, char **argv)
{
int opt;
char *configfile = "hosts";
JRB hosts, node, node2;
Host *host, *join, *me;
int nhosts;
int i, j;
Message *m;
char dest[160];
char msg[256];
Key tmp;
ChimeraHost ch;
double start;
while ((opt = getopt (argc, argv, OPTSTR)) != EOF)
{
switch ((char) opt)
{
case 'f':
configfile = optarg;
break;
default:
fprintf (stderr, "invalid option %c\n", (char) opt);
fprintf (stderr, "usage: %s\n", USAGE);
exit (1);
}
}
sem = sema_create (0);
state = (ChimeraState *) malloc (sizeof (ChimeraState));
me = (Host *) malloc (sizeof (Host));
me->name = "localhost";
me->port = 11110;
me->hnp = "localhost:11110";
hosts = read_hosts (configfile, &nhosts);
state->log = log_init ();
log_direct (state->log, LOG_ERROR, stderr);
log_direct (state->log, LOG_WARN, stderr);
key_init ();
state->message = message_init (state, 11110);
message_handler (state, 21, hello, 1);
message_handler (state, 22, fwd, 1);
message_handler (state, 23, del, 1);
message_handler (state, 24, NULL, 1);
srand (time (NULL));
/* This part runs bighost in different hosts */
announced = 0;
jrb_traverse (node, hosts)
{
if (announced == 0)
{
join = NULL;
}
else
{
i = (rand () % announced) + 1;
jrb_traverse (node2, hosts)
{
i--;
if (i == 0)
break;
}
join = (Host *) node2->val.v;
}
host = (Host *) node->val.v;
start_host (host, join);
dsleep (0.1);
}
END_TEST
START_TEST(test_dbmail_message_store)
{
DbmailMessage *m;
char *t, *e;
//-----------------------------------------
m = message_init("From: paul\n");
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(simple);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(rfc822);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(multipart_message);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(multipart_message2);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(message_rfc822);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(multipart_message3);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(multipart_message4);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(multipart_message5);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(multipart_mixed);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(broken_message);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
//COMPARE(expect,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(encoded_message_latin_1);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(encoded_message_latin_2);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(encoded_message_utf8);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(encoded_message_utf8_1);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(encoded_message_utf8_2);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(encoded_message_koi);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(raw_message_koi);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(multipart_alternative);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(outlook_multipart);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
COMPARE(e,t);
g_free(e);
g_free(t);
//-----------------------------------------
m = message_init(multipart_alternative2);
e = dbmail_message_to_string(m);
t = store_and_retrieve(m);
// FIXME COMPARE(e,t);
g_free(e);
g_free(t);
}
static void process_frames(wiced_tcp_socket_t *sock, websocket_msg_handler_t binary_msg_handler, websocket_msg_handler_t text_msg_handler, void *ctx) {
wiced_result_t ret;
char *buf, *cur;
uint32_t len;
websocket_frame_t frame;
websocket_message_t msg;
wiced_bool_t exit_loop = WICED_FALSE;
message_init(&msg);
while (WICED_TRUE) {
buf = NULL;
ret = receive_data(sock, 3000, &buf, &len);
if (ret == WICED_TIMEOUT) {
continue;
}
if (ret != WICED_SUCCESS) {
WPRINT_LIB_INFO( ("(WebSocket) Failed to read from socket (err=%u)\n", ret) );
break;
}
WPRINT_LIB_DEBUG( ("(WebSocket) Received %u bytes\n", (unsigned int)len) );
cur = buf;
while (len > 0) {
if (get_frame(&cur, &len, &frame) != WICED_SUCCESS) {
WPRINT_LIB_INFO( ("(WebSocket) Failed to read frame (err=%u)\n", ret) );
exit_loop = WICED_TRUE;
break;
}
if (frame.opcode == WS_OPCODE_PING) {
WPRINT_LIB_DEBUG( ("(WebSocket) Received PING frame.\n"));
send_control_frame(sock, WS_OPCODE_PONG, frame.payload, frame.payload_len);
}
else if (frame.opcode == WS_OPCODE_PONG) {
WPRINT_LIB_DEBUG( ("(WebSocket) Received PONG frame.\n"));
/* Nothing to do. */
}
else if (frame.opcode == WS_OPCODE_CLOSE) {
WPRINT_LIB_DEBUG( ("(WebSocket) Received CLOSE frame.\n") );
/* Echo the CLOSE frame with the 2-byte status code. */
if (frame.payload_len >= 2) {
send_control_frame(sock, WS_OPCODE_CLOSE, frame.payload, 2);
}
else {
send_control_frame(sock, WS_OPCODE_CLOSE, NULL, 0);
}
exit_loop = WICED_TRUE;
break;
}
else if (frame.opcode == WS_OPCODE_CONTINUATION) {
WPRINT_LIB_DEBUG( ("(WebSocket) Received CONTINUATION frame.\n") );
if (msg.is_active) {
message_append(&msg, frame.payload, frame.payload_len);
if (frame.is_final) {
consume_message(&msg, binary_msg_handler, text_msg_handler, ctx);
}
}
else {
exit_loop = WICED_TRUE;
break;
}
}
else if (frame.opcode == WS_OPCODE_TEXT) {
WPRINT_LIB_DEBUG( ("(WebSocket) Received TEXT frame.\n") );
if (msg.is_active) {
WPRINT_LIB_DEBUG( ("(WebSocket) A pending message already exists.\n") );
exit_loop = WICED_TRUE;
break;
}
message_start(&msg, WICED_TRUE, frame.payload, frame.payload_len);
if (frame.is_final) {
consume_message(&msg, binary_msg_handler, text_msg_handler, ctx);
}
}
else if (frame.opcode == WS_OPCODE_BINARY) {
WPRINT_LIB_DEBUG( ("(WebSocket) Received BINARY frame.\n") );
if (msg.is_active) {
WPRINT_LIB_DEBUG( ("(WebSocket) A pending message already exists.\n") );
exit_loop = WICED_TRUE;
break;
}
message_start(&msg, WICED_FALSE, frame.payload, frame.payload_len);
if (frame.is_final) {
consume_message(&msg, binary_msg_handler, text_msg_handler, ctx);
}
}
else {
WPRINT_LIB_INFO(("(WebSocket) Received invalid opcode %02X\n", frame.opcode));
exit_loop = WICED_TRUE;
break;
}
}
free(buf);
if (exit_loop) {
WPRINT_LIB_INFO( ("(WebSocket) Exiting read loop.\n") );
break;
}
}
message_deinit(&msg);
}
