// -----------------------------------------------------------------------------
// Client management functions
// -----------------------------------------------------------------------------
void *client_handler(void *args){
//Recover parameters
fprintf(stdout, "New client request.\n");
struct thread_info *tinfo = (struct thread_info*)args;
char buff[MSG_MAX_SIZE];
//Create the new client user
ServerData *server = tinfo->server;
User *user = user_create("new_user");
if(user == NULL){
fprintf(stderr, "Unable to create the user for socket %d\n", tinfo->socket);
pthread_exit(NULL);
}
user->socket = tinfo->socket;
//Listen for message
while(server->is_working == 1 && user->connected == 1){
//TODO CRIT: Add exit process
memset(buff, 0x00, sizeof(buff));
recv(user->socket, buff, MSG_MAX_SIZE, 0);
messaging_server_exec_receive(server, user, buff);
}
//Free data
fprintf(stdout, "Client deconnected\n");
user_destroy(user);
}
static void user_signed__user_serial__oneCount(void **state)
{
user_t * user = user_create("Frodo");
serials_t * ser=serials_new("Friend");
user_signed(user,ser);
assert_int_equal(1,user_get_count(user));
serials_free(ser);
user_delete(user);
}
int
useradd(const char *name)
{
if (user_created >= MAX_USER)
return - E_TOO_MANY_USERS;
// uid starts from 1
users[user_created] = user_create(user_created + 1, name);
user_created = user_created + 1;
return user_created;
}
static void user_unsigned__user_index_of_serial__twoCount(void **state)
{
user_t * user = user_create("Frodo");
serials_t * ser=serials_new("Friend");
serials_t * res=serials_new("qwer");
serials_t * qwe=serials_new("asdf");
user_signed(user,ser);
user_signed(user,res);
user_signed(user,qwe);
user_unsigned(user,0);
assert_int_equal(2,user_get_count(user));
serials_free(ser);
user_delete(user);
}
void listencb(struct evconnlistener *listener, evutil_socket_t clisockfd, struct sockaddr *addr, int len, void *ptr) {
struct event_base *eb = evconnlistener_get_base(listener);
struct bufferevent *bev = bufferevent_socket_new(eb, clisockfd, BEV_OPT_CLOSE_ON_FREE);
LOG("a user logined in, socketfd = %d", bufferevent_getfd(bev));
//create a user
user_t *user = user_create();
user->wscon->bev = bev;
user_vec.push_back(user);
//ws_conn_setcb(wscon, HANDSHAKE, testfunc, (void*)"haha");
ws_conn_setcb(user->wscon, FRAME_RECV, frame_recv_cb, user);
ws_conn_setcb(user->wscon, CLOSE, user_disconnect_cb, user);
ws_serve_start(user->wscon);
}
int main(int argc, char **argv){
system("clear");
fprintf(stdout, "Server start\n");
//check parameters (Must be: port_number)
if(argc != 2){
usage(argv[0]);
}
//Init signal process
//TODO To update
sigset_t mask, oldmask;
sethandler(SIG_IGN, SIGPIPE);
//sethandler(siginthandler, SIGINT);
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
//sigprocmask(SIG_BLOCK, &mask, &oldmask);
//Create the server socket, bind it, start listening
int sock = create_server_tcp_socket(atoi(argv[1]), BACKLOG);
if(sock < 0){
fprintf(stderr, "Unable to start the server (Unable to create the socket)...\n");
return EXIT_FAILURE;
}
//Initialize server data
ServerData server;
server_data_init(&server);
User *admin = user_create("admin"); //Admin user just for the default room
server_data_add_room(&server, admin, ROOM_WELCOME_NAME);
//Start listening for new clients
server_start_listening_clients(&server, sock);
//Close the socket
fprintf(stdout, "Server is closing. Close socket...\n");
if(TEMP_FAILURE_RETRY(close(sock)) < 0){
fprintf(stderr, "Error while closing the socket...\n");
return EXIT_FAILURE;
}
fprintf(stdout, "Server is stopped\n");
return EXIT_SUCCESS;
}
// INT 80h Handler, kernel entry.
void int_80() {
if(krn) {
return;
}
krn++;
int systemCall = kernel_buffer[0];
int fd = kernel_buffer[1];
int buffer = kernel_buffer[2];
int count = kernel_buffer[3];
int i, j;
Process * current;
Process * p;
int inode;
int _fd;
// Yeah, wanna know why we don't access an array directly? ... Because of big bugs we might have.
switch(systemCall) {
case READY:
kernel_buffer[KERNEL_RETURN] = kernel_ready();
break;
case WRITE:
current = getp();
kernel_buffer[KERNEL_RETURN] = fd_write(current->file_descriptors[fd],(char *)buffer,count);
break;
case READ:
current = getp();
kernel_buffer[KERNEL_RETURN] = fd_read(current->file_descriptors[fd],(char *)buffer,count);
break;
case MKFIFO:
_fd = process_getfreefd();
fd = fd_open(_FD_FIFO, (void *)kernel_buffer[1],kernel_buffer[2]);
if(_fd != -1 && fd != -1) {
getp()->file_descriptors[_fd] = fd;
kernel_buffer[KERNEL_RETURN] = _fd;
}
else {
kernel_buffer[KERNEL_RETURN] = -1;
}
break;
case OPEN:
_fd = process_getfreefd();
fd = fd_open(_FD_FILE, (void *) kernel_buffer[1], kernel_buffer[2]);
if(_fd != -1 && fd >= 0)
{
getp()->file_descriptors[_fd] = fd;
kernel_buffer[KERNEL_RETURN] = _fd;
}
else {
kernel_buffer[KERNEL_RETURN] = fd;
}
break;
case CLOSE:
kernel_buffer[KERNEL_RETURN] = fd_close(getp()->file_descriptors[fd]);
break;
case PCREATE:
kernel_buffer[KERNEL_RETURN] = sched_pcreate(kernel_buffer[1],kernel_buffer[2],kernel_buffer[3]);
break;
case PRUN:
kernel_buffer[KERNEL_RETURN] = sched_prun(kernel_buffer[1]);
break;
case PDUP2:
kernel_buffer[KERNEL_RETURN] = sched_pdup2(kernel_buffer[1],kernel_buffer[2],kernel_buffer[3]);
break;
case GETPID:
kernel_buffer[KERNEL_RETURN] = sched_getpid();
break;
case WAITPID:
kernel_buffer[KERNEL_RETURN] = sched_waitpid(kernel_buffer[1]);
break;
case PTICKS:
kernel_buffer[KERNEL_RETURN] = (int) storage_index();
break;
case PNAME:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) NULL;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->name;
}
break;
case PSTATUS:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->state;
}
break;
case PPRIORITY:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->priority;
}
break;
case PGID:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL)
{
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
kernel_buffer[KERNEL_RETURN] = (int) p->gid;
}
break;
case PGETPID_AT:
p = process_getbypindex(kernel_buffer[1]);
if (p->state != -1) {
kernel_buffer[KERNEL_RETURN] = (int) p->pid;
} else {
kernel_buffer[KERNEL_RETURN] = -1;
}
break;
case KILL:
kernel_buffer[KERNEL_RETURN - 1] = kernel_buffer[1];
kernel_buffer[KERNEL_RETURN - 2] = kernel_buffer[2];
break;
case PSETP:
p = process_getbypid(kernel_buffer[1]);
if(p == NULL) {
kernel_buffer[KERNEL_RETURN] = (int) -1;
} else {
if(kernel_buffer[2] <= 4 && kernel_buffer[2] >= 0) {
p->priority = kernel_buffer[2];
}
kernel_buffer[KERNEL_RETURN] = (int) p->gid;
}
break;
case SETSCHED:
sched_set_mode(kernel_buffer[1]);
break;
case PWD:
kernel_buffer[KERNEL_RETURN] = (int) fs_pwd();
break;
case CD:
kernel_buffer[KERNEL_RETURN] = (int) fs_cd(kernel_buffer[1]);
break;
case FINFO:
fs_finfo(kernel_buffer[1], kernel_buffer[2]);
break;
case MOUNT:
fs_init();
break;
case MKDIR:
kernel_buffer[KERNEL_RETURN] = (int) fs_mkdir(kernel_buffer[1],current_ttyc()->pwd);
break;
case RM:
inode = fs_indir(kernel_buffer[1],current_ttyc()->pwd);
if (inode) {
kernel_buffer[KERNEL_RETURN] = (int) fs_rm(inode,0);
} else {
kernel_buffer[KERNEL_RETURN] = ERR_NO_EXIST;
}
break;
case GETUID:
if(kernel_buffer[1] == 0)
{
kernel_buffer[KERNEL_RETURN] = (int) current_ttyc()->uid;
} else {
kernel_buffer[KERNEL_RETURN] = (int) user_exists(kernel_buffer[1]);
}
break;
case GETGID:
if(kernel_buffer[1] == 0)
{
kernel_buffer[KERNEL_RETURN] = (int) user_gid(current_ttyc()->uid);
} else {
kernel_buffer[KERNEL_RETURN] = (int) user_gid(kernel_buffer[1]);
}
break;
case MAKEUSER:
kernel_buffer[KERNEL_RETURN] = user_create(kernel_buffer[1],
kernel_buffer[2], user_gid(current_ttyc()->uid));
break;
case SETGID:
kernel_buffer[KERNEL_RETURN] = user_setgid(kernel_buffer[1],
kernel_buffer[2]);
break;
case UDELETE:
kernel_buffer[KERNEL_RETURN] = user_delete(kernel_buffer[1]);
break;
case UEXISTS:
kernel_buffer[KERNEL_RETURN] = user_exists(kernel_buffer[1]);
break;
case ULOGIN:
kernel_buffer[KERNEL_RETURN] = user_login(kernel_buffer[1],
kernel_buffer[2]);
break;
case ULOGOUT:
kernel_buffer[KERNEL_RETURN] = user_logout();
break;
case CHOWN:
kernel_buffer[KERNEL_RETURN] = fs_chown(kernel_buffer[1],
kernel_buffer[2]);
break;
case CHMOD:
kernel_buffer[KERNEL_RETURN] = fs_chmod(kernel_buffer[1],
kernel_buffer[2]);
break;
case GETOWN:
kernel_buffer[KERNEL_RETURN] = fs_getown(kernel_buffer[1]);
break;
case GETMOD:
kernel_buffer[KERNEL_RETURN] = fs_getmod(kernel_buffer[1]);
break;
case CP:
kernel_buffer[KERNEL_RETURN] = fs_cp(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd, current_ttyc()->pwd);
break;
case MV:
kernel_buffer[KERNEL_RETURN] = fs_mv(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd);
break;
case LINK:
kernel_buffer[KERNEL_RETURN] = fs_open_link(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd);
break;
case FSSTAT:
kernel_buffer[KERNEL_RETURN] = fs_stat(kernel_buffer[1]);
break;
case SLEEP:
kernel_buffer[KERNEL_RETURN] = scheduler_sleep(kernel_buffer[1]);
break;
default:
break;
}
krn--;
}
void process_client()
{
char *argv[MAX_ARGV];
char buf[BUF_SIZE];
int argc = 0;
set_signal();
print_greeting();
prompt();
while (1)
{
if (!fgets(buf, BUF_SIZE, stdin))
break;
strtok(buf, "\r\n"); // Skip everything after "\r" or "\n"
parse_argv(buf, argv, &argc); // It it sommand, so let's parse it
char *cmd = argv[0]; // At least 1 token exists
if (buf[0] != '\\') // If not command, then client wants to say something
{
say(buf);
}
else if (!strcmp(cmd, "\\quit"))
{
break;
}
else if (!strcmp(cmd, "\\help"))
{
print_help();
}
else if (!strcmp(cmd, "\\list") && argc == 1)
{
list();
}
else if (!strcmp(cmd, "\\register") && argc == 3)
{
user_create(argv[1], argv[2]); // args: user, pass
}
else if (!strcmp(cmd, "\\login") && argc == 3)
{
user_login(argv[1], argv[2]); // args: user, pass
}
else if (!strcmp(cmd, "\\create") && argc >= 2 && argc <= 3)
{
room_create(argv[1], argv[2]); // args: name, [pass]
}
else if (!strcmp(cmd, "\\join") && argc >= 2 && argc <= 3)
{
room_join(argv[1], argv[2]); // args: name, [pass]
}
else if (!strcmp(cmd, "\\leave"))
{
room_leave();
}
else
{
WriteLn("Unknown command or wrong number of arguments (type '\\help' for commands list)");
}
WriteLn("");
prompt();
}
}
static mod_ret_t _session_in_router(mod_instance_t mi, pkt_t pkt) {
sm_t sm = mi->mod->mm->sm;
int ns, iq, elem, attr;
jid_t jid;
sess_t sess = (sess_t) NULL;
mod_ret_t ret;
/* if we've got this namespace, its from a c2s */
if(pkt->nad->ecur <= 1 || (ns = nad_find_namespace(pkt->nad, 1, uri_SESSION, NULL)) < 0)
return mod_PASS;
/* don't bother if its a failure */
if(pkt->type & pkt_SESS_FAILED) {
/* !!! check failed=1, handle */
pkt_free(pkt);
return mod_HANDLED;
}
/* session commands */
if(pkt->type & pkt_SESS) {
ns = nad_find_namespace(pkt->nad, 1, uri_SESSION, NULL);
/* only end can get away without a target */
attr = nad_find_attr(pkt->nad, 1, -1, "target", NULL);
if(attr < 0 && pkt->type != pkt_SESS_END) {
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* session start */
if(pkt->type == pkt_SESS) {
jid = jid_new(NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr));
if(jid != NULL)
sess = sess_start(sm, jid);
if(jid == NULL || sess == NULL) {
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
if(jid != NULL)
jid_free(jid);
return mod_HANDLED;
}
/* c2s component that is handling this session */
strcpy(sess->c2s, pkt->rfrom->domain);
/* remember what c2s calls us */
attr = nad_find_attr(pkt->nad, 1, ns, "c2s", NULL);
snprintf(sess->c2s_id, sizeof(sess->c2s_id), "%.*s", NAD_AVAL_L(pkt->nad, attr), NAD_AVAL(pkt->nad, attr));
/* mark PBX session as fake */
if(!strncmp("PBX", sess->c2s_id, 3)) {
sess->fake = 1;
}
/* add our id */
nad_set_attr(pkt->nad, 1, ns, "sm", sess->sm_id, 0);
/* mark that it started OK */
nad_set_attr(pkt->nad, 1, -1, "action", "started", 7);
/* set this SM name */
nad_set_attr(pkt->nad, 0, -1, "to", sm->id, 0);
/* inform c2s */
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
jid_free(jid);
return mod_HANDLED;
}
/* user create */
if(pkt->type == pkt_SESS_CREATE) {
jid = jid_new(NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr));
if(jid == NULL || user_create(sm, jid) != 0) {
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
if(jid != NULL)
jid_free(jid);
return mod_HANDLED;
}
/* inform c2s */
nad_set_attr(pkt->nad, 1, -1, "action", "created", 7);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
jid_free(jid);
return mod_HANDLED;
}
/* user delete */
if(pkt->type == pkt_SESS_DELETE) {
jid = jid_new(NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr));
if(jid == NULL) {
pkt_free(pkt);
return mod_HANDLED;
}
user_delete(sm, jid);
/* inform c2s */
nad_set_attr(pkt->nad, 1, -1, "action", "deleted", 7);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
jid_free(jid);
return mod_HANDLED;
}
/* get the session id */
attr = nad_find_attr(pkt->nad, 1, ns, "sm", NULL);
if(attr < 0) {
log_debug(ZONE, "no session id, bouncing");
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* find the corresponding session */
sess = xhash_getx(sm->sessions, NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr));
/* active check */
if(sess == NULL) {
log_debug(ZONE, "session %.*s doesn't exist, bouncing", NAD_AVAL_L(pkt->nad, attr), NAD_AVAL(pkt->nad, attr));
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* make sure its from them */
attr = nad_find_attr(pkt->nad, 1, ns, "c2s", NULL);
if(attr >= 0 && (strlen(sess->c2s_id) != NAD_AVAL_L(pkt->nad, attr) || strncmp(sess->c2s_id, NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr)) != 0)) {
log_debug(ZONE, "invalid sender on route from %s for session %s (should be %s)", pkt->rfrom->domain, sess->sm_id, sess->c2s_id);
pkt_free(pkt);
return mod_HANDLED;
}
/* session end */
if(pkt->type == pkt_SESS_END) {
sm_c2s_action(sess, "ended", NULL);
sess_end(sess);
pkt_free(pkt);
return mod_HANDLED;
}
log_debug(ZONE, "unknown session packet, dropping");
pkt_free(pkt);
return mod_HANDLED;
}
/* otherwise, its a normal packet for the session */
/* #ifdef ENABLE_SUPERSEDED // FIXME XXX TODO clients are not yet ready for this */
/* check for RFC3920 session request *
* with RFC3920bis it is unneeded *
* session is activated by bind, so we just return back result */
if((ns = nad_find_scoped_namespace(pkt->nad, uri_XSESSION, NULL)) >= 0 &&
(iq = nad_find_elem(pkt->nad, 0, -1, "iq", 1)) >= 0 &&
(elem = nad_find_elem(pkt->nad, iq, ns, "session", 1)) >= 0) {
log_debug(ZONE, "session create request");
/* build a result packet */
nad_drop_elem(pkt->nad, elem);
nad_set_attr(pkt->nad, iq, -1, "type", "result", 6);
/* return the result */
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* #endif */
/* get the session id */
attr = nad_find_attr(pkt->nad, 1, ns, "sm", NULL);
if(attr < 0) {
log_debug(ZONE, "no session id, bouncing");
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* find the corresponding session */
sess = xhash_getx(sm->sessions, NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr));
/* active check */
if(sess == NULL) {
log_debug(ZONE, "session %.*s doesn't exist, bouncing", NAD_AVAL_L(pkt->nad, attr), NAD_AVAL(pkt->nad, attr));
nad_set_attr(pkt->nad, 1, ns, "failed", "1", 1);
sx_nad_write(sm->router, stanza_tofrom(pkt->nad, 0));
pkt->nad = NULL;
pkt_free(pkt);
return mod_HANDLED;
}
/* make sure its from them */
attr = nad_find_attr(pkt->nad, 1, ns, "c2s", NULL);
if(attr >= 0 && (strlen(sess->c2s_id) != NAD_AVAL_L(pkt->nad, attr) || strncmp(sess->c2s_id, NAD_AVAL(pkt->nad, attr), NAD_AVAL_L(pkt->nad, attr)) != 0)) {
log_debug(ZONE, "invalid sender on route from %s for session %s (should be %s)", jid_full(pkt->rfrom), sess->sm_id, sess->c2s_id);
pkt_free(pkt);
return mod_HANDLED;
}
/* where it came from */
pkt->source = sess;
/* hand it to the modules */
ret = mm_in_sess(pkt->sm->mm, sess, 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)
break;
else
ret = -stanza_err_FEATURE_NOT_IMPLEMENTED;
default:
pkt_sess(pkt_error(pkt, -ret), sess);
break;
}
return mod_HANDLED;
}
static void probe_net_event(struct net_connection* con, int events, void *arg)
{
struct hub_probe* probe = (struct hub_probe*) net_con_get_ptr(con);
if (events == NET_EVENT_TIMEOUT)
{
char buf[512];
ssize_t len = snprintf(buf, sizeof(buf), "This hub runs on ADC protocol only!\n\nThese are the possible reasons why you see this message:\n\n * you used address without protocol specification, e.g. example.com:1234 instead of adc://example.com:1234\n * your client does not support ADC protocol.\n|$ForceMove %s|", probe->hub->config->nmdc_only_redirect_addr);
net_con_send(con, buf, (size_t) len);
probe_destroy(probe);
return;
}
if (events & NET_EVENT_READ)
{
int bytes = net_con_peek(con, probe_recvbuf, PROBE_RECV_SIZE);
if (bytes < 0)
{
probe_destroy(probe);
return;
}
if (bytes >= 4)
{
if (memcmp(probe_recvbuf, "HSUP", 4) == 0)
{
LOG_TRACE("Probed ADC");
#ifdef SSL_SUPPORT
if (probe->hub->config->tls_enable && probe->hub->config->tls_require)
{
LOG_TRACE("Not TLS connection - closing connection.");
if (*probe->hub->config->tls_require_redirect_addr)
{
char buf[512];
ssize_t len = snprintf(buf, sizeof(buf), "ISUP " ADC_PROTO_SUPPORT "\nISID AAAB\nIINF NIRedirecting...\nIQUI AAAB RD%s\n", probe->hub->config->tls_require_redirect_addr);
net_con_send(con, buf, (size_t) len);
LOG_TRACE("Not TLS connection - Redirecting to %s.", probe->hub->config->tls_require_redirect_addr);
}
else
{
LOG_TRACE("Not TLS connection - closing connection.");
}
}
else
#endif
if (user_create(probe->hub, probe->connection, &probe->addr))
{
probe->connection = 0;
}
probe_destroy(probe);
return;
}
else if ((memcmp(probe_recvbuf, "GET ", 4) == 0) ||
(memcmp(probe_recvbuf, "POST", 4) == 0) ||
(memcmp(probe_recvbuf, "HEAD", 4) == 0))
{
/* Looks like HTTP - Not supported, but we log it. */
LOG_TRACE("Probed HTTP connection. Not supported closing connection (%s)", ip_convert_to_string(&probe->addr));
const char* buf = "501 Not implemented\r\n\r\n";
net_con_send(con, buf, strlen(buf));
}
#ifdef SSL_SUPPORT
else if (bytes >= 11 &&
probe_recvbuf[0] == 22 &&
probe_recvbuf[1] == 3 && /* protocol major version */
probe_recvbuf[5] == 1 && /* message type */
probe_recvbuf[9] == probe_recvbuf[1])
{
if (probe->hub->config->tls_enable)
{
LOG_TRACE("Probed TLS %d.%d connection", (int) probe_recvbuf[1], (int) probe_recvbuf[2]);
if (user_create(probe->hub, probe->connection, &probe->addr))
{
probe->connection = 0;
}
net_con_ssl_handshake(con, net_con_ssl_mode_server, probe->hub->ctx);
}
else
{
LOG_TRACE("Probed TLS %d.%d connection. TLS disabled in hub.", (int) probe_recvbuf[9], (int) probe_recvbuf[10]);
}
}
else
{
LOG_TRACE("Probed unsupported protocol: %x%x%x%x.", (int) probe_recvbuf[0], (int) probe_recvbuf[1], (int) probe_recvbuf[2], (int) probe_recvbuf[3]);
}
#endif
probe_destroy(probe);
return;
}
}
}
poldiff_t *poldiff_create(apol_policy_t * orig_policy, apol_policy_t * mod_policy, poldiff_handle_fn_t fn, void *callback_arg)
{
poldiff_t *diff = NULL;
int error;
if (!orig_policy || !mod_policy) {
ERR(NULL, "%s", strerror(EINVAL));
errno = EINVAL;
return NULL;
}
if (!(diff = calloc(1, sizeof(poldiff_t)))) {
ERR(NULL, "%s", strerror(ENOMEM));
errno = ENOMEM;
return NULL;
}
diff->orig_pol = orig_policy;
diff->mod_pol = mod_policy;
diff->orig_qpol = apol_policy_get_qpol(diff->orig_pol);
diff->mod_qpol = apol_policy_get_qpol(diff->mod_pol);
diff->fn = fn;
diff->handle_arg = callback_arg;
if ((diff->type_map = type_map_create()) == NULL) {
ERR(diff, "%s", strerror(ENOMEM));
poldiff_destroy(&diff);
errno = ENOMEM;
return NULL;
}
if (type_map_infer(diff) < 0) {
error = errno;
poldiff_destroy(&diff);
errno = error;
return NULL;
}
if ((diff->attrib_diffs = attrib_summary_create()) == NULL ||
(diff->avrule_diffs[AVRULE_OFFSET_ALLOW] = avrule_create()) == NULL ||
(diff->avrule_diffs[AVRULE_OFFSET_AUDITALLOW] = avrule_create()) == NULL ||
(diff->avrule_diffs[AVRULE_OFFSET_DONTAUDIT] = avrule_create()) == NULL ||
(diff->avrule_diffs[AVRULE_OFFSET_NEVERALLOW] = avrule_create()) == NULL ||
(diff->bool_diffs = bool_create()) == NULL ||
(diff->cat_diffs = cat_create()) == NULL ||
(diff->class_diffs = class_create()) == NULL ||
(diff->common_diffs = common_create()) == NULL ||
(diff->level_diffs = level_create()) == NULL ||
(diff->range_trans_diffs = range_trans_create()) == NULL ||
(diff->role_diffs = role_create()) == NULL ||
(diff->role_allow_diffs = role_allow_create()) == NULL ||
(diff->role_trans_diffs = role_trans_create()) == NULL ||
(diff->terule_diffs[TERULE_OFFSET_CHANGE] = terule_create()) == NULL ||
(diff->terule_diffs[TERULE_OFFSET_MEMBER] = terule_create()) == NULL ||
(diff->terule_diffs[TERULE_OFFSET_TRANS] = terule_create()) == NULL ||
(diff->type_diffs = type_summary_create()) == NULL || (diff->user_diffs = user_create()) == NULL) {
ERR(diff, "%s", strerror(ENOMEM));
poldiff_destroy(&diff);
errno = ENOMEM;
return NULL;
}
diff->policy_opts = QPOL_POLICY_OPTION_NO_RULES | QPOL_POLICY_OPTION_NO_NEVERALLOWS;
return diff;
}
static void user_getAct__user__notNULL(void **state)
{
user_t * user = user_create("Frodo");
assert_non_null(user_getAct(user));
user_delete(user);
}
static void new__name__zeroCount(void **state)
{
user_t * user = user_create("Frodo");
assert_int_equal(strcmp("Frodo",user_get_name(user)), 0);
user_delete(user);
}
/*! \brief user_create wrapper */
static void add_user(ATTRIBUTE_UNUSED void * data, uint32_t id, string * name)
{
user_create(id, name);
}
sess_t sess_start(sm_t sm, jid_t jid) {
pool_t p;
user_t user;
sess_t sess, scan;
sha1_state_t sha1;
unsigned char hash[20];
int replaced = 0;
log_debug(ZONE, "session requested for %s", jid_full(jid));
/* check whether it is to serviced domain */
if(xhash_get(sm->hosts, jid->domain) == NULL) {
log_write(sm->log, LOG_ERR, "request to start session in non-serviced domain: jid=%s", jid_full(jid));
return NULL;
}
/* get user data for this guy */
user = user_load(sm, jid);
/* unknown user */
if(user == NULL) {
if(config_get(sm->config, "user.auto-create") == NULL) {
log_write(sm->log, LOG_NOTICE, "user not found and user.auto-create not enabled, can't start session: jid=%s", jid_full(jid));
return NULL;
}
log_debug(ZONE, "auto-creating user %s", jid_user(jid));
if(user_create(sm, jid) != 0)
return NULL;
user = user_load(sm, jid);
if(user == NULL) {
log_write(sm->log, LOG_NOTICE, "couldn't load user, can't start session: jid=%s", jid_full(jid));
return NULL;
}
}
/* kill their old session if they have one */
for(scan = user->sessions; scan != NULL; scan = scan->next)
if(jid_compare_full(scan->jid, jid) == 0) {
log_debug(ZONE, "replacing session %s (%s)", jid_full(jid), scan->c2s_id);
/* !!! this "replaced" stuff is a hack - its really a subaction of "ended".
* hurrah, another control protocol rewrite is needed :(
*/
sm_c2s_action(scan, "replaced", NULL);
_sess_end_guts(scan);
pool_free(scan->p);
replaced = 1;
break;
}
/* make a new session */
p = pool_new();
sess = (sess_t) pmalloco(p, sizeof(struct sess_st));
sess->p = p;
/* fill it out */
sess->pri = 0;
sess->user = user;
sess->jid = jid_dup(jid);
pool_cleanup(sess->p, (void (*))(void *) jid_free, sess->jid);
/* a place for modules to store stuff */
sess->module_data = (void **) pmalloco(sess->p, sizeof(void *) * sess->user->sm->mm->nindex);
/* add it to the list */
sess->next = user->sessions;
user->sessions = sess;
/* who c2s should address things to */
sha1_init(&sha1);
datetime_out(time(NULL), dt_DATETIME, sess->sm_id, 41);
sha1_append(&sha1, sess->sm_id, strlen(sess->sm_id));
sha1_append(&sha1, jid_full(sess->jid), strlen(jid_full(sess->jid)));
sha1_finish(&sha1, hash);
hex_from_raw(hash, 20, sess->sm_id);
log_debug(ZONE, "smid is %s", sess->sm_id);
/* remember it */
xhash_put(sm->sessions, sess->sm_id, sess);
/* inform the modules */
/* !!! catch the return value - if its 1, don't let them in */
mm_sess_start(sm->mm, sess);
if(replaced)
log_write(sm->log, LOG_NOTICE, "session replaced: jid=%s", jid_full(sess->jid));
else
log_write(sm->log, LOG_NOTICE, "session started: jid=%s", jid_full(sess->jid));
return sess;
}
