sessions.c

AnyQ服务端源代码(2004/10/28)源码

        
    
        am = pmalloco(s->p, sizeof(_at_mio));
        am->p = s->p;
        am->s = s;
        am->ass = sess;
        am->conn = bosconn;

        //m = mio_new(bosconn->fd, &at_handle_mio, am, mio_handlers_new(at_session_handle_read, at_session_handle_write, NULL));

        //s->m = m;

        aim_sendcookie(sess, bosconn, info->cookie);

    }
    
    return 1;
}

/* Future expansion
int at_conninitdone_chatnav(aim_session_t *sess, aim_frame_t *command, ...)
{
  fprintf(stderr, "faimtest: chatnav: got server ready\n");
  aim_conn_addhandler(sess, command->conn, AIM_CB_FAM_CTN, AIM_CB_CTN_INFO, faimtest_chatnav_info, 0);
  aim_bos_reqrate(sess, command->conn);
  aim_chatnav_clientready(sess, command->conn);
  aim_chatnav_reqrights(sess, command->conn);
  return 1;
}

int at_conninitdone_chat(aim_session_t *sess, aim_frame_t *command, ...)
{
  aim_conn_addhandler(sess, command->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERJOIN, faimtest_chat_join, 0);
  aim_conn_addhandler(sess, command->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERLEAVE, faimtest_chat_leave, 0);
  aim_conn_addhandler(sess, command->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_ROOMINFOUPDATE, faimtest_chat_infoupdate, 0);
  aim_conn_addhandler(sess, command->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_INCOMINGMSG, faimtest_chat_incomingmsg, 0);
  aim_bos_reqrate(sess, command->conn);
  aim_chat_clientready(sess, command->conn);
  return 1;
} */

int at_handleredirect(aim_session_t *sess, aim_frame_t *command, ...)
{
  va_list ap;
  int serviceid;
  char *ip;
  unsigned char *cookie;
  at_session s;
  at_mio am;

  va_start(ap, command);
  serviceid = va_arg(ap, int);
  ip = va_arg(ap, char *);
  cookie = va_arg(ap, unsigned char *);

  s = (at_session)sess->aux_data;
 
  switch(serviceid)
  {
    case 0x0005:
    {
    	aim_conn_t *tstconn;
            
        tstconn = aim_newconn(sess, AIM_CONN_TYPE_ADS, ip);
	    if ((tstconn==NULL) || (tstconn->status & AIM_CONN_STATUS_RESOLVERR)) {
        	  log_debug(ZONE, "[AT] unable to reconnect with authorizer");
      	} else {
	      aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_FLAPVER, at_flapversion, 0);
    	  aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNCOMPLETE, at_conncomplete, 0);
	      aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, at_conninitdone_admin, 0);
    	  //aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_GEN, 0x0018, faimtest_hostversions, 0);
	      aim_sendcookie(sess, tstconn, cookie);
    	  log_debug(ZONE, "sent cookie to adverts host");
       }
	}
    break;
    case 0x0007: /* Authorizer */
      {
	aim_conn_t *tstconn;
	/* Open a connection to the Auth */
	tstconn = aim_newconn(sess, AIM_CONN_TYPE_AUTH, ip);
	if ( (tstconn==NULL) || (tstconn->status >= AIM_CONN_STATUS_RESOLVERR) )
    {
	    log_debug(ZONE, "[AT] unable to reconnect with authorizer\n");
    }
	else
    {
        aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_FLAPVER, at_flapversion, 0);
        aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNCOMPLETE, at_conncomplete, 0);
        aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, at_conninitdone_admin, 0);
	  /* Send the cookie to the Auth */
/*
        am = pmalloco(s->p, sizeof(_at_mio));
        am->p = s->p;
        am->s = s;
        am->conn = tstconn;
        am->ass = sess;
*/
        
        //mio_new(tstconn->fd, &at_handle_mio, tstconn, mio_handlers_new(at_session_handle_read, at_session_handle_write, NULL));

	    aim_sendcookie(sess, tstconn, cookie);
    }

      }  
      break;
    case 0x000d: /* XXX ChatNav */
      {
	/*aim_conn_t *tstconn = NULL;
	tstconn = aim_newconn(sess, AIM_CONN_TYPE_CHATNAV, ip);
	if ( (tstconn==NULL) || (tstconn->status >= AIM_CONN_STATUS_RESOLVERR)) {
	  fprintf(stderr, "faimtest: unable to connect to chatnav server\n");
	  if (tstconn) aim_conn_kill(sess, &tstconn);
	  return 1;
	}
	aim_conn_addhandler(sess, tstconn, 0x0001, 0x0003, faimtest_serverready, 0);
	aim_sendcookie(sess, tstconn, cookie);
	fprintf(stderr, "\achatnav: connected\n");*/
      }
      break;
    case 0x000e: /* Chat */
      {
	/*char *roomname = NULL;
	aim_conn_t *tstconn = NULL;

	roomname = va_arg(ap, char *);

	tstconn = aim_newconn(sess, AIM_CONN_TYPE_CHAT, ip);
	if ( (tstconn==NULL) || (tstconn->status >= AIM_CONN_STATUS_RESOLVERR))
	  {
	    fprintf(stderr, "faimtest: unable to connect to chat server\n");
	    if (tstconn) aim_conn_kill(sess, &tstconn);
	    return 1;
	  }		
	printf("faimtest: chat: connected\n");

	aim_chat_attachname(tstconn, roomname);

	aim_conn_addhandler(sess, tstconn, 0x0001, 0x0003, faimtest_serverready, 0);
	aim_sendcookie(sess, tstconn, cookie);*/
      }
      break;
    default:
      log_debug(ZONE, "uh oh... got redirect for unknown service 0x%04x!!\n", serviceid);
      /* dunno */
    }

  va_end(ap);

  return 1;
}

int at_parse_ratechange(aim_session_t *sess,
                        aim_frame_t *fr, ...)
{
	static const char *codes[5] = {
		"invalid",
		 "change",
		 "warning",
		 "limit",
		 "limit cleared",
	};
	va_list ap;
	fu16_t code, rateclass;
	fu32_t windowsize, clear, alert, limit, disconnect, currentavg, maxavg;
	at_session s;
	ati ti;

	s = (at_session)sess->aux_data;
	ti = s->ti;

	va_start(ap, fr); 
	code = (fu16_t)va_arg(ap, unsigned int);
	rateclass= (fu16_t)va_arg(ap, unsigned int);
	windowsize = (fu32_t)va_arg(ap, unsigned long);
	clear = (fu32_t)va_arg(ap, unsigned long);
	alert = (fu32_t)va_arg(ap, unsigned long);
	limit = (fu32_t)va_arg(ap, unsigned long);
	disconnect = (fu32_t)va_arg(ap, unsigned long);
	currentavg = (fu32_t)va_arg(ap, unsigned long);
	maxavg = (fu32_t)va_arg(ap, unsigned long);
	va_end(ap);

	log_debug(ZONE, "[AIM] rate %s (paramid 0x%04lx): curavg = %ld, maxavg = %ld, alert at %ld, "
		     "clear warning at %ld, limit at %ld, disconnect at %ld (window size = %ld)\n",
		     (code < 5) ? codes[code] : codes[0],
		     rateclass,
		     currentavg, maxavg,
		     alert, clear,
		     limit, disconnect,
		     windowsize);

	/* XXX fix these values */
	if (code == AIM_RATE_CODE_CHANGE) {
		if (currentavg >= clear)
			aim_conn_setlatency(fr->conn, 0);
	} else if (code == AIM_RATE_CODE_WARNING) {
		aim_conn_setlatency(fr->conn, 500);
	} else if (code == AIM_RATE_CODE_LIMIT) {
	        /* send rate warning message */
	        xmlnode err,error;
	        err=xmlnode_new_tag("message");
	        xmlnode_put_attrib(err,"type","error");
	        xmlnode_put_attrib(err,"from",ti->i->id);
	        xmlnode_put_attrib(err,"to",jid_full(s->cur));
	        error=xmlnode_insert_tag(err,"error");
	        xmlnode_insert_cdata(error,
	          "You are talking too fast. Message has been dropped.",-1);
	        at_deliver(ti,err);

		aim_conn_setlatency(fr->conn, 1000);
	} else if (code == AIM_RATE_CODE_CLEARLIMIT) {
		aim_conn_setlatency(fr->conn, 0);
	}

	return 1;
}

int at_parse_motd(aim_session_t *sess, 
                  aim_frame_t *command, ...)
{
/* XXX Should we do the headline?
  static char *codes[] = {
    "Unknown",
    "Mandatory upgrade",
    "Advisory upgrade",
    "System bulletin",
    "Top o' the world!"};
  static int codeslen = 5;

  char *amsg;
  unsigned short id;
  va_list ap;
  char msg[1024];
  
  va_start(ap, command);
  id = va_arg(ap, u_int);
  msg = va_arg(ap, char *);
  va_end(ap);

  printf("faimtest: motd: %s (%d / %s)\n", msg, id, 
	 (id < codeslen)?codes[id]:"unknown");
*/
  //aim_0001_0020(sess, command->conn);

  return 1;
}

int at_parse_connerr(aim_session_t *sess, 
                     aim_frame_t *command, ...)
{
  va_list ap;
  unsigned short code;
  char *msg = NULL;
  at_session s;

  s = (at_session)sess->aux_data;
  va_start(ap, command);
  code = va_arg(ap, u_int);
  msg = va_arg(ap, char *);
  va_end(ap);

  /* XXX End the session */
  aim_conn_kill(sess, &command->conn); /* this will break the main loop */

  return 1;
}

int at_flapversion(aim_session_t *sess, 
                   aim_frame_t *command, ...)
{

  return 1;
}

int at_conncomplete(aim_session_t *sess, 
                    aim_frame_t *command, ...)
{
  va_list ap;
  aim_conn_t *conn;

  va_start(ap, command);
  conn = va_arg(ap, aim_conn_t *);
  va_end(ap);
  
  return 1;
}

#if 0
at_session at_session_find_aim(int fd)
{
    aim_conn_t *cur;

    for (cur = sess->connlist; cur; cur = cur->next) {
        if (cur->status & AIM_CONN_STATUS_INPROGRESS) {
            FD_SET(cur->fd, &wfds);
            haveconnecting++;
        }
        FD_SET(cur->fd, &fds);
        if (cur->fd > maxfd)
            maxfd = cur->fd;
    }
}
#endif

#if 0
ssize_t at_session_handle_read(mio m, void* buf, size_t count)
{
    at_mio am;
    at_session s;
    aim_conn_t *conn;
    int flags;

    am = (at_mio)m->cb_arg;

    flags = fcntl(m->fd, F_GETFL, 0);
    if(flags & O_NONBLOCK)
    {
        flags &= ~O_NONBLOCK;
        if(fcntl(m->fd, F_SETFL, flags)<0)
            log_debug(ZONE, "[AT] Error calling F_SETFL to block");
    }


    /*log_debug(ZONE, "[AT] Session MIO handle read");*/
    errno = 0;
    if (aim_get_command(am->ass, am->conn) >= 0)
    {
        aim_rxdispatch(am->ass);
        return 1;
    } else {
        log_debug(ZONE, "[AT] Error handling read!");
        aim_conn_kill(am->ass, &am->conn);
        mio_close(m);
    //    at_session_end(s);
        return -1;
    }
}

ssize_t at_session_handle_write(mio m, const void* buf, size_t count)
{
    /*log_debug(ZONE, "[AT] Session MIO handle write");*/
    errno = 0;
    return count;
}

void at_handle_mio(mio m, int flags, void *arg, char *buffer, int bufsz)
{
    aim_conn_t *cur;
    at_mio am;
    at_session s;
    int sflags;

    am = (at_mio)arg;

    if(flags == MIO_NEW)
        return;

    if(flags == MIO_CLOSED || flags == MIO_ERROR)
    {
        log_debug(ZONE, "[AT] socket %d closed", m->fd);
        pool_free(am->p);
        if(am->s->loggedin == 1)
            at_session_end(am->s);
        return;
    }
}
#endif

void at_debugcb(aim_session_t *sess, int level, const char *format, va_list va)
{
    vfprintf(stderr, format, va);
    
    return;
}

at_session at_session_create(ati ti, xmlnode aim_data, jpacket jp)
{
    char *user, *pword;
    jid j, from;
    pool p;
    mio m = NULL;
    at_session new;
    aim_session_t *ass;
    aim_conn_t *authconn = NULL;
    jid jput;
    pth_attr_t attr;
    xmlnode fpres;

    user = xmlnode_get_attrib(aim_data, "id");
    pword = xmlnode_get_attrib(aim_data, "pass");

    j = jp->from;
    from = jp->to;

    new = at_session_find_by_jid(ti, j);
    if(new!=NULL)
    {
        log_debug(ZONE, "[AIM] The goober is already online");
        return NULL;
    }
    log_debug(ZONE, "[AT] Going to start session for %s", jid_full(j));
    printf("New session for %s\n", jid_full(j));
    ass = malloc(sizeof(aim_session_t));
    aim_session_init(ass, AIM_SESS_FLAGS_NONBLOCKCONNECT, 0 /* faim debug level */);
    aim_setdebuggingcb(ass, at_debugcb);

    /* Set queue mode */
    aim_tx_setenqueue(ass, AIM_TX_QUEUED, NULL);

    authconn = aim_newconn(ass, AIM_CONN_TYPE_AUTH, FAIM_LOGIN_SERVER);
    if(authconn == NULL)
    {
        xmlnode err;
        
        /* Let the user know */
        err = xmlnode_new_tag("message");
        xmlnode_put_attrib(err, "to", jid_full(j));
        xmlnode_put_attrib(err, "type", "error");
        xmlnode_put_attrib(err, "from", jid_full(from));
        jutil_error(err, (terror){500, "Error connecting to the AIM authentication server"});
        at_deliver(ti,err);

        /* Break it down */
        log_error("[AIM]", "Error connecting to aims authentication server.\n");
        return NULL;
    } 
    else if (authconn->fd == -1)
    {
        xmlnode err;
        
        /* Let the user know */
        err = xmlnode_new_tag("message");
        xmlnode_put_attrib(err, "to", jid_full(j));
        xmlnode_put_attrib(err, "type", "error");
        xmlnode_put_attrib(err, "from", jid_full(from));
        
        if (authconn->status & AIM_CONN_STATUS_RESOLVERR)
        {
            jutil_error(err, (terror){500, "Could not resolve AIM authorizer"});
            log_error("[AIM]", "at: could not resolve authorizer name");
        }
        else if (authconn->status & AIM_CONN_STATUS_CONNERR)
        {
            jutil_error(err, (terror){500, "Could not connect to AIM authorizer"});
            log_error("[AIM]", "at: could not connect to authorizer");
        }
        at_deliver(ti,err);