static void ppassed_Count_byType_wasZero_passedThreeType3(void **state)
{
terminal_t * terminal = terminal_new(1);
int funcRes = terminal_passed_count_byType(terminal,3);
int correct = 0;
assert_int_equal(funcRes,correct);
user_t * user1 =user_new("Random","guy",3);
user_t * user2 =user_new("Random","american",3);
user_t * user3 =user_new("Random","girl",3);
turnstile_t * ts1 = turnstile_new(1);
turnstile_pass(ts1,user1);
turnstile_pass(ts1,user2);
turnstile_t* ts2 = turnstile_new(2);
turnstile_pass(ts2,user3);
terminal_add_turnstile(terminal,ts1);
terminal_add_turnstile(terminal,ts2);
funcRes = terminal_passed_count_byType(terminal,3);
correct = 3;
assert_int_equal(funcRes,correct);
user_free(user1);
user_free(user2);
user_free(user3);
turnstile_free(ts1);
turnstile_free(ts2);
terminal_free(terminal);
}
void
child_deliver_action_hook(pid_t pid, struct account *a, struct msg *msg,
struct child_deliver_data *data, int *result)
{
struct actitem *ti = data->actitem;
struct deliver_ctx *dctx = data->dctx;
struct mail *m = data->mail;
struct mail *md = &dctx->wr_mail;
/* Check if this is the parent. */
if (pid != 0) {
/* Use new mail if necessary. */
if (ti->deliver->type != DELIVER_WRBACK) {
xfree(dctx);
return;
}
if (*result != DELIVER_SUCCESS)
mail_destroy(md);
else {
mail_close(md);
if (mail_receive(m, msg, 0) != 0) {
log_warn("parent_deliver: can't receive mail");
*result = DELIVER_FAILURE;
}
}
xfree(dctx);
return;
}
dctx->udata = xmalloc(sizeof *dctx->udata);
dctx->udata->uid = data->uid;
dctx->udata->gid = data->gid;
dctx->udata->name = xstrdup(find_tag(m->tags, "user"));
dctx->udata->home = xstrdup(find_tag(m->tags, "home"));
log_debug2("%s: deliver user is: %s (%lu/%lu), home is: %s", a->name,
dctx->udata->name, (u_long) dctx->udata->uid,
(u_long) dctx->udata->gid, dctx->udata->home);
/* This is the child. do the delivery. */
*result = ti->deliver->deliver(dctx, ti);
if (ti->deliver->type != DELIVER_WRBACK || *result != DELIVER_SUCCESS) {
user_free(dctx->udata);
return;
}
user_free(dctx->udata);
mail_send(md, msg);
log_debug2("%s: using new mail, size %zu", a->name, md->size);
}
static void
kos_sw_displaytarget_destroy(struct sw_winsys *winsys,
struct sw_displaytarget *dt)
{
struct kos_sw_displaytarget *gdt = kos_sw_displaytarget(dt);
user_free(gdt->data);
FREE(gdt);
}
void test_store_user(test_t *t) {
mem_init();
user_t* user = user_new();
mem_res res = mem_store_user(user);
assert_eq_int(t,res, MEM_OK);
user_free(user);
}
int
match_command_match(struct mail_ctx *mctx, struct expritem *ei)
{
struct match_command_data *data = ei->data;
struct account *a = mctx->account;
struct mail *m = mctx->mail;
struct io *io = mctx->io;
struct msg msg;
struct msgbuf msgbuf;
struct userdata *ud;
char *user;
set_wrapped(m, '\n');
/*
* We are called as the child so to change uid this needs to be done
* largely in the parent.
*/
memset(&msg, 0, sizeof msg);
msg.type = MSG_COMMAND;
msg.id = m->idx;
msg.data.account = a;
msg.data.cmddata = data;
user = conf.cmd_user;
if (data->user.str != NULL)
user = replacestr(&data->user, m->tags, m, &m->rml);
if ((ud = user_lookup(user, conf.user_order)) == NULL) {
log_warnx("%s: bad user: %s", a->name, user);
return (MATCH_ERROR);
}
if (data->user.str != NULL)
xfree(user);
msg.data.uid = ud->uid;
msg.data.gid = ud->gid;
update_tags(&m->tags, ud);
user_free(ud);
msgbuf.buf = m->tags;
msgbuf.len = STRB_SIZE(m->tags);
mail_send(m, &msg);
if (privsep_send(io, &msg, &msgbuf) != 0)
fatalx("privsep_send error");
reset_tags(&m->tags);
mctx->msgid = msg.id;
return (MATCH_PARENT);
}
int main(void)
{
srand(time(NULL));
cmocka_tests();
getchar();
system("cls");
queue_t * queue = queue_new();
user_t * user1 = user_new("User1");
user_t * user2 = user_new("User2");
user_t * user3 = user_new("User3");
user_t * userArr[] =
{
user1,
user2,
user3
};
int userArrSize = sizeof(userArr)/sizeof(userArr[0]);
event_t* firstEvent = event_new("First event");
event_t* secondEvent = event_new("Second event");
event_t* thirdEvent = event_new("Third event");
event_addReceiver(firstEvent, user1, alert_callback);
event_addReceiver(firstEvent, user2, alert_callback);
event_addReceiver(secondEvent, user1, alert_callback);
event_addReceiver(thirdEvent, user1, alert_callback);
event_addReceiver(secondEvent, user2, alert_callback);
event_addReceiver(thirdEvent, user3, alert_callback);
event_addReceiver(secondEvent, user3, alert_callback);
event_addReceiver(thirdEvent, user2, alert_callback);
while(!kbhit() && queue_status(queue) != QUEUE_FULL)
{
queue_start(firstEvent, secondEvent, thirdEvent, queue);
}
event_free(firstEvent);
event_free(secondEvent);
event_free(thirdEvent);
for(int i = 0; i<userArrSize; i++)
user_free(userArr[i]);
queue_free(queue);
return 0;
}
void user_free_array(size_t size,user_t * user[size])
{
for(int i=0;i<size;i++)
{
if(user[i]==NULL)
{
status = USER_ERROR_NULL_PTR;
return;
}
user_free(user[i]);
status = USER_OK;
}
}
void test_lookup_non_exsisting_user(test_t *t) {
mem_init();
user_t *user = user_new_with_name("test");
mem_store_user(user);
user_t *found = NULL;
mem_res res = mem_lookup_user("test-non", &found);
assert_eq_int(t,MEM_NOTFOUND, res);
assert(t,"'found' is not nil", NULL == found);
user_free(user);
}
void test_lookup_existing_user(test_t *t) {
mem_init();
user_t *user = user_new_with_name("test");
mem_store_user(user);
user_t *found = NULL;
mem_res res = mem_lookup_user("test", &found);
assert_eq_int(t,MEM_OK, res);
assert_eq_str(t,"test", found->username);
user_free(user);
}
void sess_end(sess_t sess) {
log_debug(ZONE, "shutting down session %s", jid_full(sess->jid));
_sess_end_guts(sess);
log_write(sess->user->sm->log, LOG_NOTICE, "session ended: jid=%s", jid_full(sess->jid));
/* if it was the last session, free the user */
if(sess->user->sessions == NULL) {
mm_user_unload(sess->user->sm->mm, sess->user);
log_write(sess->user->sm->log, LOG_NOTICE, "user unloaded jid=%s", jid_user(sess->jid));
user_free(sess->user);
}
/* free the session */
pool_free(sess->p);
}
int main(void) {
srand(time(NULL));
cmockaTest();
puts("\nPress ANY KEY to continue...");
getch();
system("cls");
queue_t * myQueue = queue_new();
user_t * me = user_new("Me");
user_t * firstuser = user_new("First");
user_t * seconduser = user_new("Second");
user_t * users[] = { me, firstuser, seconduser };
int usersSize = sizeof(users) / sizeof(users[0]);
event_t * firstEvent = event_new("10 measurements \\ everything OK (1st event)");
event_t * secondEvent = event_new("last 5 measurements \\ not everything OK (2d event)");
event_t * thirdEvent = event_new("last 5 measurements \\ everything NOT OK (3d event)");
event_addAlertSingle(me, firstEvent, alert_fantasy);
event_addAlertSingle(me, secondEvent, alert_master);
event_addAlertSeveral(users, usersSize, thirdEvent, alert_common);
while (!kbhit()) {
event_start(firstEvent, secondEvent, thirdEvent, myQueue);
}
event_free(firstEvent);
event_free(secondEvent);
event_free(thirdEvent);
for (int i = 0; i < usersSize; i++) {
user_free(users[i]);
}
queue_free(myQueue);
getch();
puts("Press ANY KEY to exit the program...");
getch();
return 0;
}
void manager_free(Manager *m) {
Session *session;
User *u;
Device *d;
Seat *s;
Inhibitor *i;
Button *b;
assert(m);
while ((session = hashmap_first(m->sessions)))
session_free(session);
while ((u = hashmap_first(m->users)))
user_free(u);
while ((d = hashmap_first(m->devices)))
device_free(d);
while ((s = hashmap_first(m->seats)))
seat_free(s);
while ((i = hashmap_first(m->inhibitors)))
inhibitor_free(i);
while ((b = hashmap_first(m->buttons)))
button_free(b);
hashmap_free(m->devices);
hashmap_free(m->seats);
hashmap_free(m->sessions);
hashmap_free(m->users);
hashmap_free(m->inhibitors);
hashmap_free(m->buttons);
hashmap_free(m->user_units);
hashmap_free(m->session_units);
set_free_free(m->busnames);
sd_event_source_unref(m->idle_action_event_source);
sd_event_source_unref(m->console_active_event_source);
sd_event_source_unref(m->udev_seat_event_source);
sd_event_source_unref(m->udev_device_event_source);
sd_event_source_unref(m->udev_vcsa_event_source);
sd_event_source_unref(m->udev_button_event_source);
sd_event_source_unref(m->lid_switch_ignore_event_source);
safe_close(m->console_active_fd);
if (m->udev_seat_monitor)
udev_monitor_unref(m->udev_seat_monitor);
if (m->udev_device_monitor)
udev_monitor_unref(m->udev_device_monitor);
if (m->udev_vcsa_monitor)
udev_monitor_unref(m->udev_vcsa_monitor);
if (m->udev_button_monitor)
udev_monitor_unref(m->udev_button_monitor);
if (m->udev)
udev_unref(m->udev);
bus_verify_polkit_async_registry_free(m->bus, m->polkit_registry);
sd_bus_unref(m->bus);
sd_event_unref(m->event);
safe_close(m->reserve_vt_fd);
strv_free(m->kill_only_users);
strv_free(m->kill_exclude_users);
free(m->action_job);
free(m);
}
/** main packet dispatcher */
void dispatch(sm_t sm, pkt_t pkt) {
user_t user;
mod_ret_t ret;
/* handle broadcasts */
if(pkt->rtype == route_BROADCAST) {
log_debug(ZONE, "can't handle broadcast routes (yet), dropping");
pkt_free(pkt);
return;
}
/* routing errors, add a im error */
if(pkt->rtype & route_ERROR) {
int i, aerror, stanza_err;
aerror = nad_find_attr(pkt->nad, 0, -1, "error", NULL);
stanza_err = stanza_err_REMOTE_SERVER_NOT_FOUND;
if(aerror >= 0) {
for(i=0; _stanza_errors[i].code != NULL; i++)
if(strncmp(_stanza_errors[i].code, NAD_AVAL(pkt->nad, aerror), NAD_AVAL_L(pkt->nad, aerror)) == 0) {
stanza_err = stanza_err_BAD_REQUEST + i;
break;
}
}
if(pkt_error(pkt, stanza_err) == NULL)
return;
}
/*
* - if its from the router (non-route) it goes straight to pkt_router
* - hand it to in_router chain
* - if its for the sm itself (no user), hand it to the pkt_sm chain
* - find the user
* - hand to pkt_user
*/
/* non route packets are special-purpose things from the router */
if(!(pkt->rtype & route_UNICAST)) {
ret = mm_pkt_router(pkt->sm->mm, pkt);
switch(ret) {
case mod_HANDLED:
break;
case mod_PASS:
default:
/* don't ever bounce these */
pkt_free(pkt);
break;
}
return;
}
/* preprocessing */
if (pkt != NULL && pkt->sm != NULL) {
ret = mm_in_router(pkt->sm->mm, pkt);
switch(ret) {
case mod_HANDLED:
return;
case mod_PASS:
break;
default:
pkt_router(pkt_error(pkt, -ret));
return;
}
}
/* has to come from someone and be directed to someone */
if(pkt->from == NULL || pkt->to == NULL) {
pkt_router(pkt_error(pkt, stanza_err_BAD_REQUEST));
return;
}
/* packet is for the sm itself */
if(*pkt->to->node == '\0') {
ret = mm_pkt_sm(pkt->sm->mm, pkt);
switch(ret) {
case mod_HANDLED:
break;
case mod_PASS:
/* ignore IQ result packets that haven't been handled - XMPP 9.2.3.4 */
if(pkt->type == pkt_IQ_RESULT) {
pkt_free(pkt);
break;
} else
ret = -stanza_err_FEATURE_NOT_IMPLEMENTED;
default:
pkt_router(pkt_error(pkt, -ret));
break;
}
return;
}
/* get the user */
user = user_load(sm, pkt->to);
if(user == NULL) {
if(pkt->type & pkt_PRESENCE && pkt->type != pkt_PRESENCE_PROBE) {
pkt_free(pkt);
return;
}
if(pkt->type == pkt_PRESENCE_PROBE) {
pkt_router(pkt_create(pkt->sm, "presence", "unsubscribed", jid_full(pkt->from), jid_full(pkt->to)));
pkt_free(pkt);
return;
}
pkt_router(pkt_error(pkt, stanza_err_SERVICE_UNAVAILABLE));
return;
}
if (pkt->sm != NULL) {
ret = mm_pkt_user(pkt->sm->mm, user, pkt);
switch(ret) {
case mod_HANDLED:
break;
case mod_PASS:
/* ignore IQ result packets that haven't been handled - XMPP 9.2.3.4 */
if(pkt->type == pkt_IQ_RESULT) {
pkt_free(pkt);
break;
} else
ret = -stanza_err_FEATURE_NOT_IMPLEMENTED;
default:
pkt_router(pkt_error(pkt, -ret));
break;
}
}
/* if they have no sessions, they were only loaded to do delivery, so free them */
if(user->sessions == NULL)
user_free(user);
}
static void manager_free(Manager *m) {
Session *session;
User *u;
Device *d;
Seat *s;
Inhibitor *i;
Button *b;
assert(m);
while ((session = hashmap_first(m->sessions)))
session_free(session);
while ((u = hashmap_first(m->users)))
user_free(u);
while ((d = hashmap_first(m->devices)))
device_free(d);
while ((s = hashmap_first(m->seats)))
seat_free(s);
while ((i = hashmap_first(m->inhibitors)))
inhibitor_free(i);
while ((b = hashmap_first(m->buttons)))
button_free(b);
hashmap_free(m->devices);
hashmap_free(m->seats);
hashmap_free(m->sessions);
hashmap_free(m->users);
hashmap_free(m->inhibitors);
hashmap_free(m->buttons);
hashmap_free(m->user_units);
hashmap_free(m->session_units);
sd_event_source_unref(m->idle_action_event_source);
sd_event_source_unref(m->inhibit_timeout_source);
sd_event_source_unref(m->scheduled_shutdown_timeout_source);
sd_event_source_unref(m->nologin_timeout_source);
sd_event_source_unref(m->wall_message_timeout_source);
sd_event_source_unref(m->console_active_event_source);
sd_event_source_unref(m->udev_seat_event_source);
sd_event_source_unref(m->udev_device_event_source);
sd_event_source_unref(m->udev_vcsa_event_source);
sd_event_source_unref(m->udev_button_event_source);
sd_event_source_unref(m->lid_switch_ignore_event_source);
safe_close(m->console_active_fd);
udev_monitor_unref(m->udev_seat_monitor);
udev_monitor_unref(m->udev_device_monitor);
udev_monitor_unref(m->udev_vcsa_monitor);
udev_monitor_unref(m->udev_button_monitor);
udev_unref(m->udev);
if (m->unlink_nologin)
(void) unlink("/run/nologin");
bus_verify_polkit_async_registry_free(m->polkit_registry);
sd_bus_unref(m->bus);
sd_event_unref(m->event);
safe_close(m->reserve_vt_fd);
strv_free(m->kill_only_users);
strv_free(m->kill_exclude_users);
free(m->scheduled_shutdown_type);
free(m->scheduled_shutdown_tty);
free(m->wall_message);
free(m->action_job);
free(m);
}
void message_free(message_t * msg){
user_free(msg->owner);
free(msg);
}
Datum
custom_check(PG_FUNCTION_ARGS) {
char *us = GET_STR(PG_GETARG_TEXT_P(0));
char *ge = GET_STR(PG_GETARG_TEXT_P(1));
short i;
short is_tag;
char *tag = NULL;
char *value = NULL;
struct User u = {NULL, NULL, 0, NULL, 0, NULL, 0};
short test;
short ok;
ok = 0;
tag = init_char();
value = init_char();
is_tag = 1;
for (i=0;us[i]!='\0';i++) {
if (us[i] == ':') {
is_tag = 0;
} else if (us[i] == 'T') {
append_char(&tag, us[i]);
is_tag = 0;
} else if (us[i] == ',') {
user_add(&u, tag, value);
is_tag = 1;
pfree(tag);
tag = init_char();
value = init_char();
} else if (is_tag == 1) {
append_char(&tag, us[i]);
} else {
append_char(&value, us[i]);
}
}
user_add(&u, tag, value);
pfree(tag);
test = 1;
ok = 0;
tag = init_char();
value = init_char();
is_tag = 1;
for (i=0;ge[i]!='\0';i++) {
if (ge[i] == ':') {
is_tag = 0;
} else if (ge[i] == 'T') {
append_char(&tag, ge[i]);
is_tag = 0;
} else if (ge[i] == '+') {
is_tag = 1;
test *= check(u, tag, value);
pfree(value);
pfree(tag);
if (test == 1)
ok = 1;
test = 1;
tag = init_char();
value = init_char();
} else if (ge[i] == '*') {
is_tag = 1;
test *= check(u, tag, value);
pfree(tag);
pfree(value);
tag = init_char();
value = init_char();
} else if (is_tag) {
append_char(&tag, ge[i]);
} else {
append_char(&value, ge[i]);
}
}
test *= check(u, tag, value);
if (test == 1)
ok = 1;
pfree(tag);
pfree(value);
user_free(u);
PG_RETURN_BOOL(ok == 1);
}
int http_load_file(const char *path, const char *url)
{
http_t *http;
int received = 0;
int offset = 0;
int tail;
char *buf;
int fd;
int i;
buf = user_alloc(BUFFSIZE);
for(i = 0; i < 16; i++)
buf[i*4096] = 0;
fd = open(path, O_CREAT|O_WRONLY);
if(fd == -1)
{
user_free(buf);
return 0;
};
http = http_get(url, NULL,FLAG_STREAM|FLAG_REUSE_BUFFER, NULL);
if(http == NULL)
goto err_get;
do
{
if(http_receive_with_retry(http, 500) == 0)
{
int count;
// if(http->flags & 0xffff0000)
// break;
count = http->content_received - received;
if(count+offset <= BUFFSIZE)
{
memcpy(buf+offset, http->content_ptr, count);
offset+= count;
}
else
{
tail = count+offset-BUFFSIZE;
count = BUFFSIZE - offset;
if(count)
{
memcpy(buf+offset, http->content_ptr, count);
offset = 0;
};
write(fd, buf, BUFFSIZE);
if(tail)
{
memcpy(buf, http->content_ptr+count, tail);
offset = tail;
}
sprintf(conbuf, "%d bytes loaded\r", http->content_received);
con_write_asciiz(conbuf);
}
received = http->content_received;
}
else break;
} while( (http->flags & FLAG_GOT_ALL_DATA) == 0);
if(offset)
{
write(fd, buf, offset);
}
// ftruncate(fd, received);
close(fd);
if(http->content_ptr)
user_free(http->content_ptr);
http_free(http);
user_free(buf);
return received;
err_get:
printf("HTTP GET failed\n");
return received;
}
void session_free( Session* s ){
if( s->user && ( s->flags & SESSION_FLAGUSERID ) ) user_free( s->user );
free( s );
}
