Пример #1
0
int handle_server_data(char *in_buf, char *handle, int in_len, int socket_num) {
   Header *header = (Header *)in_buf;
   int code = 0; 
   switch (header->flag) {
      case 2:
         code = 3;
         break;
      case 3:
         printf("\nHandle already in use: %s\n", handle);
         code = 1;
         break;
      case 4:
         handle_incoming_broadcast(in_buf + sizeof(Header));
         break;
      case 5:
         handle_incoming_message(in_buf + sizeof(Header));
         break;
      case 6:
         code = 3;
         break;
      case 7:
         handle_send_error(in_buf + sizeof(Header));
         break;
      case 9:
         code = 2;
         break;
      case 11:
         handle_incoming_list(in_buf + sizeof(Header), in_len, socket_num);
         break;
      default:
         code = 3;
         break;
   }
   return code;
}
Пример #2
0
void* watch_port_for_requests_from_clients(void*sz_watchport)
/*
Purpose:Watch a port for incoming messages from clients.
	A 'message' could be a request to login/logout or
	a ping, or perhaps a request to backup/restore data.
Params: sz_watchport - the port to watch for incoming messages
	from clients
Return: result (0=success, nonzero=failure)
NB:	Function will return nonzero if error occurs during
	setup but will otherwise run forever, or until killed.
*/
{
  int watch_port;
  struct sockaddr_in sin;
  char buf[MAX_STR_LEN+1];
  int len, s, new_s;
  struct s_client2server_msg_record rec;

  watch_port = atoi((char*)sz_watchport);
//  sprintf(tmp, "watch_port_for_requests_from_clients(%d) - starting", watch_port); log_it(debug, tmp);
  memset((void*)&sin, 0, sizeof(sin));
  sin.sin_family = AF_INET;
  sin.sin_addr.s_addr = INADDR_ANY;
  sin.sin_port = htons(watch_port);
  if ((s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
    {
      log_it(error, "Unable to open socket on port #%d", watch_port);
      return((void*)-1);
    }
  if (bind(s, (struct sockaddr*)&sin, sizeof(sin)) < 0)
    {
      log_it(error, "Cannot bind %d - %s\n", watch_port, strerror(errno));
      return((void*)-1);
    }
  if (listen(s, MAX_PENDING) < 0)
    {
      log_it(error, "Cannot setup listen (%d) - %s\n", watch_port, strerror(errno));
      return((void*)-1);
    }
  /* service incoming connections */
  log_it(debug, "Bound port #%d OK", watch_port);
  while(true)
    {
      len = sizeof(sin);
      if ((new_s = accept(s, (struct sockaddr *)&sin, (unsigned int*)&len)) < 0)
	{
	  sleep(1);
	  continue;
	}
      while ((len = recv(new_s, buf, sizeof(buf), 0)) > 0)
	{
	  if (len > MAX_STR_LEN) { len = MAX_STR_LEN; }
	  buf[len] = '\0';
	  memcpy((char*)&rec, buf, sizeof(rec));
	  handle_incoming_message(new_s, &sin, &rec);
	}
      close(new_s);
    }
  return(NULL);
}
Пример #3
0
/** Sends a user message to remote node via associated kernel connection. */
int send_user_message(int target_slot_type, int target_slot_index, int data_length, char* data) {
	struct nl_msg* msg = NULL;
	struct nl_msg *ans_msg = NULL;
	struct nlmsghdr *nl_hdr;
	struct genlmsghdr* genl_hdr;
	struct nlattr *nla;

	int ret_val = 0;

	if ( (ret_val=prepare_request_message(state.handle, DIRECTOR_SEND_GENERIC_USER_MESSAGE, state.gnl_fid, &msg) ) != 0 ) {
		goto done;
  	}

  	ret_val = nla_put_u32(msg,
			   DIRECTOR_A_SLOT_TYPE,
			   target_slot_type);
	if (ret_val != 0)
    		goto done;
    	
  	ret_val = nla_put_u32(msg,
			   DIRECTOR_A_SLOT_INDEX,
			   target_slot_index);
	if (ret_val != 0)
    		goto done;

  	ret_val = nla_put_u32(msg,
			   DIRECTOR_A_LENGTH,
			   data_length);
	if (ret_val != 0)
    		goto done;

	ret_val = nla_put(msg, DIRECTOR_A_USER_DATA, data_length, data);
	if (ret_val != 0)
    		goto done;

  	if ( (ret_val = send_request_message(state.handle, msg, 1) ) != 0 )
    		goto done;

	if ( (ret_val = read_message(state.handle, &ans_msg) ) != 0 ) {
	      goto done;
	}

	// TODO: We are not checking, the ack is for this request. Check it!
	while ( !is_ack_message(ans_msg) ) {
	    // We can get different than ack messega here.. in this case we have to process it
	    handle_incoming_message(ans_msg);
	    
	    if ( (ret_val = read_message(state.handle, &ans_msg) ) != 0 ) {
		  goto done;
	    }	  
	}

done:
	nlmsg_free(ans_msg);
	return ret_val;
}
Пример #4
0
/** Runs loop that waits for a new messages and dispatches them */
int run_processing_callback(int allow_block) {
	struct nl_msg *msg = NULL;	
	int res;
	
	//printf("Starting processing loop\n");
	while (1) {
		//struct timeval start, end;
		//gettimeofday(&start);
//		printf("New netlink message arrived\n");
		if ( !allow_block && read_would_block(state.handle) ) 
			return;

		if ( (res = read_message(state.handle, &msg) ) != 0 ) {
			printf("Error in message reading: %d\n", res);
			if ( res == -EINTR ) // Interrupted => finish the thread
				break;
			continue;
		}
		
		handle_incoming_message(msg);		
	}
}
Пример #5
0
static int
_chat_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
    void * const userdata)
{
    xmpp_ctx_t *ctx = connection_get_ctx();
    gchar *from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
    Jid *jid = jid_create(from);

    // private message from chat room use full jid (room/nick)
    if (muc_active(jid->barejid)) {
        // determine if the notifications happened whilst offline
        GTimeVal tv_stamp;
        gboolean delayed = stanza_get_delay(stanza, &tv_stamp);

        // check for and deal with message
        xmpp_stanza_t *body = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BODY);
        if (body != NULL) {
            char *message = xmpp_stanza_get_text(body);
            if (message != NULL) {
                if (delayed) {
                    handle_delayed_private_message(jid->str, message, tv_stamp);
                } else {
                    handle_incoming_private_message(jid->str, message);
                }
                xmpp_free(ctx, message);
            }
        }

        jid_destroy(jid);
        return 1;

    // standard chat message, use jid without resource
    } else {
        // determine chatstate support of recipient
        gboolean recipient_supports = FALSE;
        if (stanza_contains_chat_state(stanza)) {
            recipient_supports = TRUE;
        }

        // create or update chat session
        if (!chat_session_exists(jid->barejid)) {
            chat_session_start(jid->barejid, recipient_supports);
        } else {
            chat_session_set_recipient_supports(jid->barejid, recipient_supports);
        }

        // determine if the notifications happened whilst offline
        GTimeVal tv_stamp;
        gboolean delayed = stanza_get_delay(stanza, &tv_stamp);

        // deal with chat states if recipient supports them
        if (recipient_supports && (!delayed)) {
            if (xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_COMPOSING) != NULL) {
                handle_typing(jid->barejid);
            } else if (xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_GONE) != NULL) {
                handle_gone(jid->barejid);
            } else if (xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_PAUSED) != NULL) {
                // do something
            } else if (xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_INACTIVE) != NULL) {
                // do something
            } else { // handle <active/>
                // do something
            }
        }

        // check for and deal with message
        xmpp_stanza_t *body = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BODY);
        if (body != NULL) {
            char *message = xmpp_stanza_get_text(body);
            if (message != NULL) {
                if (delayed) {
                    handle_delayed_message(jid->barejid, message, tv_stamp);
                } else {
                    handle_incoming_message(jid->barejid, message);
                }
                xmpp_free(ctx, message);
            }
        }

        jid_destroy(jid);
        return 1;
    }
}