Changeset c36f73b


Ignore:
Timestamp:
2010-07-23T14:35:45Z (9 years ago)
Author:
Wilmer van der Gaast <wilmer@…>
Branches:
master
Children:
9034ba0
Parents:
938c305
Message:

This should mostly be a no-op, merging *loads* of whitespace changes from
libyahoo2 so that I can see better what really changed.

Location:
protocols/yahoo
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • protocols/yahoo/libyahoo2.c

    r938c305 rc36f73b  
    33 *
    44 * Some code copyright (C) 2002-2004, Philip S Tellis <philip.tellis AT gmx.net>
     5 * YMSG16 code copyright (C) 2009,
     6 *              Siddhesh Poyarekar <siddhesh dot poyarekar at gmail dot com>
    57 *
    68 * Yahoo Search copyright (C) 2003, Konstantin Klyagin <konst AT konst.org.ua>
     
    2729 *     <hiro-y@kcn.ne.jp>
    2830 *
     31 * YMSG16 authentication code based mostly on write-up at:
     32 *      http://www.carbonize.co.uk/ymsg16.html
    2933 *
    3034 * This program is free software; you can redistribute it and/or modify
     
    9296
    9397#ifdef USE_STRUCT_CALLBACKS
    94 struct yahoo_callbacks *yc=NULL;
    95 
    96 void yahoo_register_callbacks(struct yahoo_callbacks * tyc)
     98struct yahoo_callbacks *yc = NULL;
     99
     100void yahoo_register_callbacks(struct yahoo_callbacks *tyc)
    97101{
    98102        yc = tyc;
     
    106110static int yahoo_send_data(int fd, void *data, int len);
    107111
    108 int yahoo_log_message(char * fmt, ...)
     112int yahoo_log_message(char *fmt, ...)
    109113{
    110114        char out[1024];
     
    113117        vsnprintf(out, sizeof(out), fmt, ap);
    114118        va_end(ap);
    115         return YAHOO_CALLBACK(ext_yahoo_log)("%s", out);
    116 }
    117 
    118 int yahoo_connect(char * host, int port)
    119 {
    120         return YAHOO_CALLBACK(ext_yahoo_connect)(host, port);
     119        return YAHOO_CALLBACK(ext_yahoo_log) ("%s", out);
     120}
     121
     122int yahoo_connect(char *host, int port)
     123{
     124        return YAHOO_CALLBACK(ext_yahoo_connect) (host, port);
    121125}
    122126
     
    138142static char pager_host[] = "scs.msg.yahoo.com";
    139143static int pager_port = 5050;
    140 static int fallback_ports[]={23, 25, 80, 20, 119, 8001, 8002, 5050, 0};
    141 static char filetransfer_host[]="filetransfer.msg.yahoo.com";
    142 static int filetransfer_port=80;
    143 static char webcam_host[]="webcam.yahoo.com";
    144 static int webcam_port=5100;
    145 static char webcam_description[]="";
    146 static char local_host[]="";
    147 static int conn_type=Y_WCM_DSL;
     144static int fallback_ports[] = { 23, 25, 80, 20, 119, 8001, 8002, 5050, 0 };
     145static char filetransfer_host[] = "filetransfer.msg.yahoo.com";
     146static int filetransfer_port = 80;
     147static char webcam_host[] = "webcam.yahoo.com";
     148static int webcam_port = 5100;
     149static char webcam_description[] = "";
     150static char local_host[] = "";
     151static int conn_type = Y_WCM_DSL;
    148152
    149153static char profile_url[] = "http://profiles.yahoo.com/";
     
    215219        YAHOO_SERVICE_PICTURE_UPDATE = 0xc1,
    216220        YAHOO_SERVICE_PICTURE_UPLOAD = 0xc2,
    217         YAHOO_SERVICE_Y6_VISIBILITY=0xc5,
    218         YAHOO_SERVICE_Y6_STATUS_UPDATE=0xc6,
    219         YAHOO_PHOTOSHARE_INIT=0xd2,     
    220         YAHOO_SERVICE_CONTACT_YMSG13=0xd6,
    221         YAHOO_PHOTOSHARE_PREV=0xd7,
    222         YAHOO_PHOTOSHARE_KEY=0xd8,
    223         YAHOO_PHOTOSHARE_TRANS=0xda,
    224         YAHOO_FILE_TRANSFER_INIT_YMSG13=0xdc,
    225         YAHOO_FILE_TRANSFER_GET_YMSG13=0xdd,
    226         YAHOO_FILE_TRANSFER_PUT_YMSG13=0xde,
    227         YAHOO_SERVICE_YMSG15_STATUS=0xf0,
    228         YAHOO_SERVICE_YMSG15_BUDDY_LIST=0xf1,
     221        YAHOO_SERVICE_Y6_VISIBILITY = 0xc5,
     222        YAHOO_SERVICE_Y6_STATUS_UPDATE = 0xc6,
     223        YAHOO_PHOTOSHARE_INIT = 0xd2,   
     224        YAHOO_SERVICE_CONTACT_YMSG13 = 0xd6,
     225        YAHOO_PHOTOSHARE_PREV = 0xd7,
     226        YAHOO_PHOTOSHARE_KEY = 0xd8,
     227        YAHOO_PHOTOSHARE_TRANS = 0xda,
     228        YAHOO_FILE_TRANSFER_INIT_YMSG13 = 0xdc,
     229        YAHOO_FILE_TRANSFER_GET_YMSG13 = 0xdd,
     230        YAHOO_FILE_TRANSFER_PUT_YMSG13 = 0xde,
     231        YAHOO_SERVICE_YMSG15_STATUS = 0xf0,
     232        YAHOO_SERVICE_YMSG15_BUDDY_LIST = 0xf1,
    229233};
    230234
     
    242246
    243247struct yahoo_search_state {
    244         int   lsearch_type;
    245         char  *lsearch_text;
    246         int   lsearch_gender;
    247         int   lsearch_agerange;
    248         int   lsearch_photo;
    249         int   lsearch_yahoo_only;
    250         int   lsearch_nstart;
    251         int   lsearch_nfound;
    252         int   lsearch_ntotal;
     248        int lsearch_type;
     249        char *lsearch_text;
     250        int lsearch_gender;
     251        int lsearch_agerange;
     252        int lsearch_photo;
     253        int lsearch_yahoo_only;
     254        int lsearch_nstart;
     255        int lsearch_nfound;
     256        int lsearch_ntotal;
    253257};
    254258
     
    264268        struct yahoo_search_state *ys;
    265269
    266         int   fd;
     270        int fd;
    267271        enum yahoo_connection_type type;
    268272       
    269         unsigned char   *rxqueue;
    270         int   rxlen;
    271         int   read_tag;
     273        unsigned char *rxqueue;
     274        int rxlen;
     275        int read_tag;
    272276
    273277        YList *txqueues;
    274         int   write_tag;
     278        int write_tag;
    275279};
    276280
    277281struct yahoo_server_settings {
    278282        char *pager_host;
    279         int   pager_port;
     283        int pager_port;
    280284        char *filetransfer_host;
    281         int   filetransfer_port;
     285        int filetransfer_port;
    282286        char *webcam_host;
    283         int   webcam_port;
     287        int webcam_port;
    284288        char *webcam_description;
    285289        char *local_host;
    286         int   conn_type;
     290        int conn_type;
    287291};
    288292
    289 static void * _yahoo_default_server_settings()
     293static void *_yahoo_default_server_settings()
    290294{
    291295        struct yahoo_server_settings *yss = y_new0(struct yahoo_server_settings, 1);
     
    304308}
    305309
    306 static void * _yahoo_assign_server_settings(va_list ap)
     310static void *_yahoo_assign_server_settings(va_list ap)
    307311{
    308312        struct yahoo_server_settings *yss = _yahoo_default_server_settings();
    309313        char *key;
    310314        char *svalue;
    311         int   nvalue;
    312 
    313         while(1) {
     315        int nvalue;
     316
     317        while (1) {
    314318                key = va_arg(ap, char *);
    315                 if(key == NULL)
    316                         break;
    317 
    318                 if(!strcmp(key, "pager_host")) {
     319                if (key == NULL)
     320                        break;
     321
     322                if (!strcmp(key, "pager_host")) {
    319323                        svalue = va_arg(ap, char *);
    320324                        free(yss->pager_host);
    321325                        yss->pager_host = strdup(svalue);
    322                 } else if(!strcmp(key, "pager_port")) {
     326                } else if (!strcmp(key, "pager_port")) {
    323327                        nvalue = va_arg(ap, int);
    324328                        yss->pager_port = nvalue;
    325                 } else if(!strcmp(key, "filetransfer_host")) {
     329                } else if (!strcmp(key, "filetransfer_host")) {
    326330                        svalue = va_arg(ap, char *);
    327331                        free(yss->filetransfer_host);
    328332                        yss->filetransfer_host = strdup(svalue);
    329                 } else if(!strcmp(key, "filetransfer_port")) {
     333                } else if (!strcmp(key, "filetransfer_port")) {
    330334                        nvalue = va_arg(ap, int);
    331335                        yss->filetransfer_port = nvalue;
    332                 } else if(!strcmp(key, "webcam_host")) {
     336                } else if (!strcmp(key, "webcam_host")) {
    333337                        svalue = va_arg(ap, char *);
    334338                        free(yss->webcam_host);
    335339                        yss->webcam_host = strdup(svalue);
    336                 } else if(!strcmp(key, "webcam_port")) {
     340                } else if (!strcmp(key, "webcam_port")) {
    337341                        nvalue = va_arg(ap, int);
    338342                        yss->webcam_port = nvalue;
    339                 } else if(!strcmp(key, "webcam_description")) {
     343                } else if (!strcmp(key, "webcam_description")) {
    340344                        svalue = va_arg(ap, char *);
    341345                        free(yss->webcam_description);
    342346                        yss->webcam_description = strdup(svalue);
    343                 } else if(!strcmp(key, "local_host")) {
     347                } else if (!strcmp(key, "local_host")) {
    344348                        svalue = va_arg(ap, char *);
    345349                        free(yss->local_host);
    346350                        yss->local_host = strdup(svalue);
    347                 } else if(!strcmp(key, "conn_type")) {
     351                } else if (!strcmp(key, "conn_type")) {
    348352                        nvalue = va_arg(ap, int);
    349353                        yss->conn_type = nvalue;
    350354                } else {
    351355                        WARNING(("Unknown key passed to yahoo_init, "
    352                                 "perhaps you didn't terminate the list "
    353                                 "with NULL"));
     356                                        "perhaps you didn't terminate the list "
     357                                        "with NULL"));
    354358                }
    355359        }
     
    360364static void yahoo_free_server_settings(struct yahoo_server_settings *yss)
    361365{
    362         if(!yss)
     366        if (!yss)
    363367                return;
    364368
     
    372376}
    373377
    374 static YList *conns=NULL;
    375 static YList *inputs=NULL;
    376 static int last_id=0;
     378static YList *conns = NULL;
     379static YList *inputs = NULL;
     380static int last_id = 0;
    377381
    378382static void add_to_list(struct yahoo_data *yd)
     
    380384        conns = y_list_prepend(conns, yd);
    381385}
    382 static struct yahoo_data * find_conn_by_id(int id)
     386static struct yahoo_data *find_conn_by_id(int id)
    383387{
    384388        YList *l;
    385         for(l = conns; l; l = y_list_next(l)) {
     389        for (l = conns; l; l = y_list_next(l)) {
    386390                struct yahoo_data *yd = l->data;
    387                 if(yd->client_id == id)
     391                if (yd->client_id == id)
    388392                        return yd;
    389393        }
     
    396400
    397401/* call repeatedly to get the next one */
    398 static struct yahoo_input_data * find_input_by_id(int id)
     402static struct yahoo_input_data *find_input_by_id(int id)
    399403{
    400404        YList *l;
     
    407411}
    408412
    409 static struct yahoo_input_data * find_input_by_id_and_webcam_user(int id, const char * who)
     413static struct yahoo_input_data *find_input_by_id_and_webcam_user(int id, const char *who)
    410414{
    411415        YList *l;
    412416        LOG(("find_input_by_id_and_webcam_user"));
    413         for(l = inputs; l; l = y_list_next(l)) {
     417        for (l = inputs; l; l = y_list_next(l)) {
    414418                struct yahoo_input_data *yid = l->data;
    415                 if(yid->type == YAHOO_CONNECTION_WEBCAM && yid->yd->client_id == id
     419                if (yid->type == YAHOO_CONNECTION_WEBCAM && yid->yd->client_id == id
    416420                                && yid->wcm &&
    417421                                ((who && yid->wcm->user && !strcmp(who, yid->wcm->user)) ||
     
    422426}
    423427
    424 static struct yahoo_input_data * find_input_by_id_and_type(int id, enum yahoo_connection_type type)
     428static struct yahoo_input_data *find_input_by_id_and_type(int id, enum yahoo_connection_type type)
    425429{
    426430        YList *l;
    427431        LOG(("find_input_by_id_and_type"));
    428         for(l = inputs; l; l = y_list_next(l)) {
     432        for (l = inputs; l; l = y_list_next(l)) {
    429433                struct yahoo_input_data *yid = l->data;
    430                 if(yid->type == type && yid->yd->client_id == id)
     434                if (yid->type == type && yid->yd->client_id == id)
    431435                        return yid;
    432436        }
     
    434438}
    435439
    436 static struct yahoo_input_data * find_input_by_id_and_fd(int id, int fd)
     440static struct yahoo_input_data *find_input_by_id_and_fd(int id, int fd)
    437441{
    438442        YList *l;
    439443        LOG(("find_input_by_id_and_fd"));
    440         for(l = inputs; l; l = y_list_next(l)) {
     444        for (l = inputs; l; l = y_list_next(l)) {
    441445                struct yahoo_input_data *yid = l->data;
    442                 if(yid->fd == fd && yid->yd->client_id == id)
     446                if (yid->fd == fd && yid->yd->client_id == id)
    443447                        return yid;
    444448        }
     
    448452static int count_inputs_with_id(int id)
    449453{
    450         int c=0;
     454        int c = 0;
    451455        YList *l;
    452456        LOG(("counting %d", id));
    453         for(l = inputs; l; l = y_list_next(l)) {
     457        for (l = inputs; l; l = y_list_next(l)) {
    454458                struct yahoo_input_data *yid = l->data;
    455                 if(yid->yd->client_id == id)
     459                if (yid->yd->client_id == id)
    456460                        c++;
    457461        }
     
    464468
    465469/* Free a buddy list */
    466 static void yahoo_free_buddies(YList * list)
     470static void yahoo_free_buddies(YList *list)
    467471{
    468472        YList *l;
    469473
    470         for(l = list; l; l = l->next)
    471         {
     474        for (l = list; l; l = l->next) {
    472475                struct yahoo_buddy *bud = l->data;
    473                 if(!bud)
     476                if (!bud)
    474477                        continue;
    475478
     
    477480                FREE(bud->id);
    478481                FREE(bud->real_name);
    479                 if(bud->yab_entry) {
     482                if (bud->yab_entry) {
    480483                        FREE(bud->yab_entry->fname);
    481484                        FREE(bud->yab_entry->lname);
     
    496499
    497500/* Free an identities list */
    498 static void yahoo_free_identities(YList * list)
     501static void yahoo_free_identities(YList *list)
    499502{
    500503        while (list) {
     
    690693}
    691694
    692 
    693695static void yahoo_packet_dump(unsigned char *data, int len)
    694696{
    695         if(yahoo_get_log_level() >= YAHOO_LOG_DEBUG) {
     697        if (yahoo_get_log_level() >= YAHOO_LOG_DEBUG) {
    696698                int i;
    697699                for (i = 0; i < len; i++) {
    698700                        if ((i % 8 == 0) && i)
    699                                 YAHOO_CALLBACK(ext_yahoo_log)(" ");
     701                                YAHOO_CALLBACK(ext_yahoo_log) (" ");
    700702                        if ((i % 16 == 0) && i)
    701                                 YAHOO_CALLBACK(ext_yahoo_log)("\n");
    702                         YAHOO_CALLBACK(ext_yahoo_log)("%02x ", data[i]);
    703                 }
    704                 YAHOO_CALLBACK(ext_yahoo_log)("\n");
     703                                YAHOO_CALLBACK(ext_yahoo_log) ("\n");
     704                        YAHOO_CALLBACK(ext_yahoo_log) ("%02x ", data[i]);
     705                }
     706                YAHOO_CALLBACK(ext_yahoo_log) ("\n");
    705707                for (i = 0; i < len; i++) {
    706708                        if ((i % 8 == 0) && i)
    707                                 YAHOO_CALLBACK(ext_yahoo_log)(" ");
     709                                YAHOO_CALLBACK(ext_yahoo_log) (" ");
    708710                        if ((i % 16 == 0) && i)
    709                                 YAHOO_CALLBACK(ext_yahoo_log)("\n");
     711                                YAHOO_CALLBACK(ext_yahoo_log) ("\n");
    710712                        if (isprint(data[i]))
    711                                 YAHOO_CALLBACK(ext_yahoo_log)(" %c ", data[i]);
     713                                YAHOO_CALLBACK(ext_yahoo_log) (" %c ", data[i]);
    712714                        else
    713                                 YAHOO_CALLBACK(ext_yahoo_log)(" . ");
    714                 }
    715                 YAHOO_CALLBACK(ext_yahoo_log)("\n");
     715                                YAHOO_CALLBACK(ext_yahoo_log) (" . ");
     716                }
     717                YAHOO_CALLBACK(ext_yahoo_log) ("\n");
    716718        }
    717719}
     
    723725}
    724726
    725 static void yahoo_add_to_send_queue(struct yahoo_input_data *yid, void *data, int length)
     727static void yahoo_add_to_send_queue(struct yahoo_input_data *yid, void *data,
     728        int length)
    726729{
    727730        struct data_queue *tx = y_new0(struct data_queue, 1);
     
    732735        yid->txqueues = y_list_append(yid->txqueues, tx);
    733736
    734         if(!yid->write_tag)
    735                 yid->write_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, yid->fd, YAHOO_INPUT_WRITE, yid);
    736 }
    737 
    738 static void yahoo_send_packet(struct yahoo_input_data *yid, struct yahoo_packet *pkt, int extra_pad)
     737        if (!yid->write_tag)
     738                yid->write_tag =
     739                        YAHOO_CALLBACK(ext_yahoo_add_handler) (yid->yd->
     740                        client_id, yid->fd, YAHOO_INPUT_WRITE, yid);
     741}
     742
     743static void yahoo_send_packet(struct yahoo_input_data *yid,
     744        struct yahoo_packet *pkt, int extra_pad)
    739745{
    740746        int pktlen = yahoo_packet_length(pkt);
    741747        int len = YAHOO_PACKET_HDRLEN + pktlen;
    742 
    743748        unsigned char *data;
    744749        int pos = 0;
     
    749754        data = y_new0(unsigned char, len + 1);
    750755
    751         memcpy(data + pos, "YMSG", 4); pos += 4;
    752         pos += yahoo_put16(data + pos, YAHOO_PROTO_VER);
    753         pos += yahoo_put16(data + pos, 0x0000);
    754         pos += yahoo_put16(data + pos, pktlen + extra_pad);
    755         pos += yahoo_put16(data + pos, pkt->service);
    756         pos += yahoo_put32(data + pos, pkt->status);
    757         pos += yahoo_put32(data + pos, pkt->id);
     756        memcpy(data + pos, "YMSG", 4);
     757        pos += 4;
     758        pos += yahoo_put16(data + pos, YAHOO_PROTO_VER);        /* version [latest 12 0x000c] */
     759        pos += yahoo_put16(data + pos, 0x0000); /* HIWORD pkt length??? */
     760        pos += yahoo_put16(data + pos, pktlen + extra_pad);     /* LOWORD pkt length? */
     761        pos += yahoo_put16(data + pos, pkt->service);   /* service */
     762        pos += yahoo_put32(data + pos, pkt->status);    /* status [4bytes] */
     763        pos += yahoo_put32(data + pos, pkt->id);        /* session [4bytes] */
    758764
    759765        yahoo_packet_write(pkt, data + pos);
    760766
    761767        yahoo_packet_dump(data, len);
    762        
    763         if( yid->type == YAHOO_CONNECTION_FT )
     768
     769        if (yid->type == YAHOO_CONNECTION_FT)
    764770                yahoo_send_data(yid->fd, data, len);
    765771        else
     
    794800        do {
    795801                ret = write(fd, data, len);
    796         } while(ret == -1 && errno==EINTR);
    797         e=errno;
    798 
    799         if (ret == -1)  {
     802        } while (ret == -1 && errno == EINTR);
     803        e = errno;
     804
     805        if (ret == -1) {
    800806                LOG(("wrote data: ERR %s", strerror(errno)));
    801807        } else {
     
    803809        }
    804810
    805         errno=e;
     811        errno = e;
    806812        return ret;
    807813}
    808814
    809 void yahoo_close(int id) 
     815void yahoo_close(int id)
    810816{
    811817        struct yahoo_data *yd = find_conn_by_id(id);
    812        
    813         if(!yd)
     818        if (!yd)
    814819                return;
    815820
     
    817822
    818823        yahoo_free_data(yd);
    819         if(id == last_id)
     824        if (id == last_id)
    820825                last_id--;
    821826}
    822827
    823 static void yahoo_input_close(struct yahoo_input_data *yid) 
     828static void yahoo_input_close(struct yahoo_input_data *yid)
    824829{
    825830        inputs = y_list_remove(inputs, yid);
    826831
    827         LOG(("yahoo_input_close(read)"));
    828         YAHOO_CALLBACK(ext_yahoo_remove_handler)(yid->yd->client_id, yid->read_tag);
    829         LOG(("yahoo_input_close(write)"));
    830         YAHOO_CALLBACK(ext_yahoo_remove_handler)(yid->yd->client_id, yid->write_tag);
     832        LOG(("yahoo_input_close(read)"));
     833        YAHOO_CALLBACK(ext_yahoo_remove_handler) (yid->yd->client_id,
     834                yid->read_tag);
     835        LOG(("yahoo_input_close(write)"));
     836        YAHOO_CALLBACK(ext_yahoo_remove_handler) (yid->yd->client_id,
     837                yid->write_tag);
    831838        yid->read_tag = yid->write_tag = 0;
    832         if(yid->fd)
     839        if (yid->fd)
    833840                close(yid->fd);
    834841        yid->fd = 0;
    835842        FREE(yid->rxqueue);
    836         if(count_inputs_with_id(yid->yd->client_id) == 0) {
     843        if (count_inputs_with_id(yid->yd->client_id) == 0) {
    837844                LOG(("closing %d", yid->yd->client_id));
    838845                yahoo_close(yid->yd->client_id);
    839846        }
    840847        yahoo_free_webcam(yid->wcm);
    841         if(yid->wcd)
     848        if (yid->wcd)
    842849                FREE(yid->wcd);
    843         if(yid->ys) {
     850        if (yid->ys) {
    844851                FREE(yid->ys->lsearch_text);
    845852                FREE(yid->ys);
     
    848855}
    849856
    850 static int is_same_bud(const void * a, const void * b) {
     857static int is_same_bud(const void *a, const void *b)
     858{
    851859        const struct yahoo_buddy *subject = a;
    852860        const struct yahoo_buddy *object = b;
     
    855863}
    856864
    857 static char * getcookie(char *rawcookie)
    858 {
    859         char * cookie=NULL;
    860         char * tmpcookie;
    861         char * cookieend;
    862 
    863         if (strlen(rawcookie) < 2) 
     865static char *getcookie(char *rawcookie)
     866{
     867        char *cookie = NULL;
     868        char *tmpcookie;
     869        char *cookieend;
     870
     871        if (strlen(rawcookie) < 2)
    864872                return NULL;
    865873
    866         tmpcookie = strdup(rawcookie+2);
     874        tmpcookie = strdup(rawcookie + 2);
    867875        cookieend = strchr(tmpcookie, ';');
    868876
    869         if(cookieend)
     877        if (cookieend)
    870878                *cookieend = '\0';
    871879
     
    877885}
    878886
    879 static char * getlcookie(char *cookie)
     887static char *getlcookie(char *cookie)
    880888{
    881889        char *tmp;
     
    884892
    885893        tmpend = strstr(cookie, "n=");
    886         if(tmpend) {
    887                 tmp = strdup(tmpend+2);
     894        if (tmpend) {
     895                tmp = strdup(tmpend + 2);
    888896                tmpend = strchr(tmp, '&');
    889                 if(tmpend)
    890                         *tmpend='\0';
     897                if (tmpend)
     898                        *tmpend = '\0';
    891899                login_cookie = strdup(tmp);
    892900                FREE(tmp);
     
    896904}
    897905
    898 static void yahoo_process_notify(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     906static void yahoo_process_notify(struct yahoo_input_data *yid,
     907        struct yahoo_packet *pkt)
    899908{
    900909        struct yahoo_data *yd = yid->yd;
     
    927936        if (!msg)
    928937                return;
    929        
    930         if (!strncasecmp(msg, "TYPING", strlen("TYPING")))
    931                 YAHOO_CALLBACK(ext_yahoo_typing_notify)(yd->client_id, to, from, stat);
    932         else if (!strncasecmp(msg, "GAME", strlen("GAME")))
    933                 YAHOO_CALLBACK(ext_yahoo_game_notify)(yd->client_id, to, from, stat);
    934         else if (!strncasecmp(msg, "WEBCAMINVITE", strlen("WEBCAMINVITE")))
    935         {
     938
     939        if (!strncasecmp(msg, "TYPING", strlen("TYPING")))
     940                YAHOO_CALLBACK(ext_yahoo_typing_notify) (yd->client_id, to,
     941                        from, stat);
     942        else if (!strncasecmp(msg, "GAME", strlen("GAME")))
     943                YAHOO_CALLBACK(ext_yahoo_game_notify) (yd->client_id, to, from,
     944                        stat);
     945        else if (!strncasecmp(msg, "WEBCAMINVITE", strlen("WEBCAMINVITE"))) {
    936946                if (!strcmp(ind, " ")) {
    937                         YAHOO_CALLBACK(ext_yahoo_webcam_invite)(yd->client_id, to, from);
     947                        YAHOO_CALLBACK(ext_yahoo_webcam_invite) (yd->client_id,
     948                                to, from);
    938949                } else {
    939950                        accept = atoi(ind);
     
    941952                        if (accept < 0)
    942953                                accept = 0;
    943                         YAHOO_CALLBACK(ext_yahoo_webcam_invite_reply)(yd->client_id, to, from, accept);
    944                 }
    945         }
    946         else
     954                        YAHOO_CALLBACK(ext_yahoo_webcam_invite_reply) (yd->
     955                                client_id, to, from, accept);
     956                }
     957        } else
    947958                LOG(("Got unknown notification: %s", msg));
    948959}
     
    951962{
    952963        struct yahoo_data *yd = yid->yd;
    953         char *from=NULL;
    954         char *to=NULL;
    955         char *msg=NULL;
    956         char *url=NULL;
    957         long expires=0;
    958 
    959         char *service=NULL;
    960 
    961         char *filename=NULL;
    962         unsigned long filesize=0L;
     964        char *from = NULL;
     965        char *to = NULL;
     966        char *msg = NULL;
     967        char *url = NULL;
     968        long expires = 0;
     969
     970        char *service = NULL;
     971
     972        char *filename = NULL;
     973        unsigned long filesize = 0L;
    963974
    964975        YList *l;
     
    985996        }
    986997
    987         if(pkt->service == YAHOO_SERVICE_P2PFILEXFER) {
    988                 if(strcmp("FILEXFER", service) != 0) {
     998        if (pkt->service == YAHOO_SERVICE_P2PFILEXFER) {
     999                if (strcmp("FILEXFER", service) != 0) {
    9891000                        WARNING(("unhandled service 0x%02x", pkt->service));
    9901001                        yahoo_dump_unhandled(pkt);
     
    9931004        }
    9941005
    995         if(msg) {
     1006        if (msg) {
    9961007                char *tmp;
    9971008                tmp = strchr(msg, '\006');
    998                 if(tmp)
     1009                if (tmp)
    9991010                        *tmp = '\0';
    10001011        }
    1001         if(url && from)
    1002                 YAHOO_CALLBACK(ext_yahoo_got_file)(yd->client_id, to, from, url, expires, msg, filename, filesize);
     1012        if (url && from)
     1013                YAHOO_CALLBACK(ext_yahoo_got_file) (yd->client_id, to, from, url, expires, msg, filename, filesize);
    10031014
    10041015}
     
    10121023        char *room = NULL;
    10131024        char *id = NULL;
    1014         int  utf8 = 0;
     1025        int utf8 = 0;
    10151026        YList *members = NULL;
    10161027        YList *l;
    1017        
     1028
    10181029        for (l = pkt->hash; l; l = l->next) {
    10191030                struct yahoo_pair *pair = l->data;
    10201031                if (pair->key == 50)
    10211032                        host = pair->value;
    1022                
    1023                 if (pair->key == 52) {          /* invite */
     1033
     1034                if (pair->key == 52) {  /* invite */
    10241035                        members = y_list_append(members, strdup(pair->value));
    10251036                }
    1026                 if (pair->key == 53)            /* logon */
     1037                if (pair->key == 53)    /* logon */
    10271038                        who = pair->value;
    1028                 if (pair->key == 54)            /* decline */
     1039                if (pair->key == 54)    /* decline */
    10291040                        who = pair->value;
    1030                 if (pair->key == 55)            /* unavailable (status == 2) */
     1041                if (pair->key == 55)    /* unavailable (status == 2) */
    10311042                        who = pair->value;
    1032                 if (pair->key == 56)            /* logoff */
     1043                if (pair->key == 56)    /* logoff */
    10331044                        who = pair->value;
    10341045
     
    10361047                        room = pair->value;
    10371048
    1038                 if (pair->key == 58)            /* join message */
     1049                if (pair->key == 58)    /* join message */
    10391050                        msg = pair->value;
    1040                 if (pair->key == 14)            /* decline/conf message */
     1051                if (pair->key == 14)    /* decline/conf message */
    10411052                        msg = pair->value;
    10421053
    1043                 if (pair->key == 13)
    1044                         ;
    1045                 if (pair->key == 16)            /* error */
     1054                if (pair->key == 13) ;
     1055                if (pair->key == 16)    /* error */
    10461056                        msg = pair->value;
    10471057
    1048                 if (pair->key == 1)             /* my id */
     1058                if (pair->key == 1)     /* my id */
    10491059                        id = pair->value;
    1050                 if (pair->key == 3)             /* message sender */
     1060                if (pair->key == 3)     /* message sender */
    10511061                        who = pair->value;
    10521062
     
    10551065        }
    10561066
    1057         if(!room)
    1058                 return;
    1059 
    1060         if(host) {
    1061                 for(l = members; l; l = l->next) {
    1062                         char * w = l->data;
    1063                         if(!strcmp(w, host))
     1067        if (!room)
     1068                return;
     1069
     1070        if (host) {
     1071                for (l = members; l; l = l->next) {
     1072                        char *w = l->data;
     1073                        if (!strcmp(w, host))
    10641074                                break;
    10651075                }
    1066                 if(!l)
     1076                if (!l)
    10671077                        members = y_list_append(members, strdup(host));
    10681078        }
    10691079        /* invite, decline, join, left, message -> status == 1 */
    10701080
    1071         switch(pkt->service) {
     1081        switch (pkt->service) {
    10721082        case YAHOO_SERVICE_CONFINVITE:
    1073                 if(pkt->status == 2)
    1074                         ;
    1075                 else if(members)
    1076                         YAHOO_CALLBACK(ext_yahoo_got_conf_invite)(yd->client_id, id, host, room, msg, members);
    1077                 else if(msg)
    1078                         YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, msg, 0, E_CONFNOTAVAIL);
     1083                if (pkt->status == 2) ;
     1084                else if (members)
     1085                        YAHOO_CALLBACK(ext_yahoo_got_conf_invite) (yd->
     1086                                client_id, id, host, room, msg, members);
     1087                else if (msg)
     1088                        YAHOO_CALLBACK(ext_yahoo_error) (yd->client_id, msg, 0,
     1089                                E_CONFNOTAVAIL);
    10791090                break;
    10801091        case YAHOO_SERVICE_CONFADDINVITE:
    1081                 if(pkt->status == 2)
     1092                if (pkt->status == 2)
    10821093                        ;
    10831094                else
    1084                         YAHOO_CALLBACK(ext_yahoo_got_conf_invite)(yd->client_id, id, host, room, msg, members);
     1095                        YAHOO_CALLBACK(ext_yahoo_got_conf_invite) (yd->client_id, id, host, room, msg, members);
    10851096                break;
    10861097        case YAHOO_SERVICE_CONFDECLINE:
    1087                 if(who)
    1088                         YAHOO_CALLBACK(ext_yahoo_conf_userdecline)(yd->client_id, id, who, room, msg);
     1098                if (who)
     1099                        YAHOO_CALLBACK(ext_yahoo_conf_userdecline) (yd->
     1100                                client_id, id, who, room, msg);
    10891101                break;
    10901102        case YAHOO_SERVICE_CONFLOGON:
    1091                 if(who)
    1092                         YAHOO_CALLBACK(ext_yahoo_conf_userjoin)(yd->client_id, id, who, room);
     1103                if (who)
     1104                        YAHOO_CALLBACK(ext_yahoo_conf_userjoin) (yd->client_id,
     1105                                id, who, room);
    10931106                break;
    10941107        case YAHOO_SERVICE_CONFLOGOFF:
    1095                 if(who)
    1096                         YAHOO_CALLBACK(ext_yahoo_conf_userleave)(yd->client_id, id, who, room);
     1108                if (who)
     1109                        YAHOO_CALLBACK(ext_yahoo_conf_userleave) (yd->client_id,
     1110                                id, who, room);
    10971111                break;
    10981112        case YAHOO_SERVICE_CONFMSG:
    1099                 if(who)
    1100                         YAHOO_CALLBACK(ext_yahoo_conf_message)(yd->client_id, id, who, room, msg, utf8);
     1113                if (who)
     1114                        YAHOO_CALLBACK(ext_yahoo_conf_message) (yd->client_id,
     1115                                id, who, room, msg, utf8);
    11011116                break;
    11021117        }
    11031118}
    11041119
    1105 static void yahoo_process_chat(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     1120static void yahoo_process_chat(struct yahoo_input_data *yid,
     1121        struct yahoo_packet *pkt)
    11061122{
    11071123        char *msg = NULL;
     
    11121128        YList *members = NULL;
    11131129        struct yahoo_chat_member *currentmember = NULL;
    1114         int  msgtype = 1;
    1115         int  utf8 = 0;
    1116         int  firstjoin = 0;
    1117         int  membercount = 0;
    1118         int  chaterr=0;
     1130        int msgtype = 1;
     1131        int utf8 = 0;
     1132        int firstjoin = 0;
     1133        int membercount = 0;
     1134        int chaterr = 0;
    11191135        YList *l;
    11201136       
     
    11481164
    11491165                        if (pkt->service == YAHOO_SERVICE_CHATJOIN) {
    1150                                 currentmember = y_new0(struct yahoo_chat_member, 1);
     1166                                currentmember =
     1167                                        y_new0(struct yahoo_chat_member, 1);
    11511168                                currentmember->id = strdup(pair->value);
    11521169                                members = y_list_append(members, currentmember);
     
    11781195                }
    11791196
    1180 
    11811197                if (pair->key == 130) {
    11821198                        /* first join */
     
    11961212                        /* message error not sure what all the pair values mean */
    11971213                        /* but -1 means no session in room */
    1198                         chaterr= atoi(pair->value);
    1199                 }
    1200         }
    1201 
    1202         if(!room) {
    1203                 if (pkt->service == YAHOO_SERVICE_CHATLOGOUT) { /* yahoo originated chat logout */
    1204                         YAHOO_CALLBACK(ext_yahoo_chat_yahoologout)(yid->yd->client_id, id);
    1205                         return ;
    1206                 }
    1207                 if (pkt->service == YAHOO_SERVICE_COMMENT && chaterr)  {
    1208                         YAHOO_CALLBACK(ext_yahoo_chat_yahooerror)(yid->yd->client_id, id);
     1214                        chaterr = atoi(pair->value);
     1215                }
     1216        }
     1217
     1218        if (!room) {
     1219                if (pkt->service == YAHOO_SERVICE_CHATLOGOUT) { /* yahoo originated chat logout */
     1220                        YAHOO_CALLBACK(ext_yahoo_chat_yahoologout) (yid->yd->
     1221                                client_id, id);
    12091222                        return;
    12101223                }
     1224                if (pkt->service == YAHOO_SERVICE_COMMENT && chaterr) {
     1225                        YAHOO_CALLBACK(ext_yahoo_chat_yahooerror) (yid->yd->
     1226                                client_id, id);
     1227                        return;
     1228                }
    12111229
    12121230                WARNING(("We didn't get a room name, ignoring packet"));
     
    12141232        }
    12151233
    1216         switch(pkt->service) {
     1234        switch (pkt->service) {
    12171235        case YAHOO_SERVICE_CHATJOIN:
    1218                 if(y_list_length(members) != membercount) {
     1236                if (y_list_length(members) != membercount) {
    12191237                        WARNING(("Count of members doesn't match No. of members we got"));
    12201238                }
    1221                 if(firstjoin && members) {
    1222                         YAHOO_CALLBACK(ext_yahoo_chat_join)(yid->yd->client_id, id, room, topic, members, yid->fd);
    1223                 } else if(who) {
    1224                         if(y_list_length(members) != 1) {
     1239                if (firstjoin && members) {
     1240                        YAHOO_CALLBACK(ext_yahoo_chat_join) (yid->yd->client_id,
     1241                                id, room, topic, members, yid->fd);
     1242                } else if (who) {
     1243                        if (y_list_length(members) != 1) {
    12251244                                WARNING(("Got more than 1 member on a normal join"));
    12261245                        }
    12271246                        /* this should only ever have one, but just in case */
    1228                         while(members) {
     1247                        while (members) {
    12291248                                YList *n = members->next;
    12301249                                currentmember = members->data;
    1231                                 YAHOO_CALLBACK(ext_yahoo_chat_userjoin)(yid->yd->client_id, id, room, currentmember);
     1250                                YAHOO_CALLBACK(ext_yahoo_chat_userjoin) (yid->
     1251                                        yd->client_id, id, room, currentmember);
    12321252                                y_list_free_1(members);
    1233                                 members=n;
     1253                                members = n;
    12341254                        }
    12351255                }
    12361256                break;
    12371257        case YAHOO_SERVICE_CHATEXIT:
    1238                 if(who) {
    1239                         YAHOO_CALLBACK(ext_yahoo_chat_userleave)(yid->yd->client_id, id, room, who);
     1258                if (who) {
     1259                        YAHOO_CALLBACK(ext_yahoo_chat_userleave) (yid->yd->
     1260                                client_id, id, room, who);
    12401261                }
    12411262                break;
    12421263        case YAHOO_SERVICE_COMMENT:
    1243                 if(who) {
    1244                         YAHOO_CALLBACK(ext_yahoo_chat_message)(yid->yd->client_id, id, who, room, msg, msgtype, utf8);
     1264                if (who) {
     1265                        YAHOO_CALLBACK(ext_yahoo_chat_message) (yid->yd->
     1266                                client_id, id, who, room, msg, msgtype, utf8);
    12451267                }
    12461268                break;
     
    12481270}
    12491271
    1250 static void yahoo_process_message(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     1272static void yahoo_process_message(struct yahoo_input_data *yid,
     1273        struct yahoo_packet *pkt)
    12511274{
    12521275        struct yahoo_data *yd = yid->yd;
    12531276        YList *l;
    1254         YList * messages = NULL;
     1277        YList *messages = NULL;
    12551278
    12561279        struct m {
    1257                 int  i_31;
    1258                 int  i_32;
     1280                int i_31;
     1281                int i_32;
    12591282                char *to;
    12601283                char *from;
    12611284                long tm;
    12621285                char *msg;
    1263                 int  utf8;
     1286                int utf8;
    12641287        } *message = y_new0(struct m, 1);
    12651288
    12661289        for (l = pkt->hash; l; l = l->next) {
    12671290                struct yahoo_pair *pair = l->data;
    1268                 if (pair->key == 1 || pair->key == 4)
    1269                 {
    1270                         if(!message->from)
     1291                if (pair->key == 1 || pair->key == 4) {
     1292                        if (!message->from)
    12711293                                message->from = pair->value;
    1272                 }
    1273                 else if (pair->key == 5)
     1294                } else if (pair->key == 5)
    12741295                        message->to = pair->value;
    12751296                else if (pair->key == 15)
     
    12811302                        message->msg = pair->value;
    12821303                else if (pair->key == 31) {
    1283                         if(message->i_31) {
     1304                        if (message->i_31) {
    12841305                                messages = y_list_append(messages, message);
    12851306                                message = y_new0(struct m, 1);
    12861307                        }
    12871308                        message->i_31 = atoi(pair->value);
    1288                 }
    1289                 else if (pair->key == 32)
     1309                } else if (pair->key == 32)
    12901310                        message->i_32 = atoi(pair->value);
    12911311                else
    1292                         LOG(("yahoo_process_message: status: %d, key: %d, value: %s",
    1293                                         pkt->status, pair->key, pair->value));
     1312                        LOG(("yahoo_process_message: status: %d, key: %d, value: %s", pkt->status, pair->key, pair->value));
    12941313        }
    12951314
    12961315        messages = y_list_append(messages, message);
    12971316
    1298         for (l = messages; l; l=l->next) {
     1317        for (l = messages; l; l = l->next) {
    12991318                message = l->data;
    13001319                if (pkt->service == YAHOO_SERVICE_SYSMESSAGE) {
    1301                         YAHOO_CALLBACK(ext_yahoo_system_message)(yd->client_id, message->msg);
     1320                        YAHOO_CALLBACK(ext_yahoo_system_message) (yd->client_id, message->msg);
    13021321                } else if (pkt->status <= 2 || pkt->status == 5) {
    1303                         YAHOO_CALLBACK(ext_yahoo_got_im)(yd->client_id, message->to, message->from, message->msg, message->tm, pkt->status, message->utf8);
     1322                        YAHOO_CALLBACK(ext_yahoo_got_im) (yd->client_id, message->to, message->from, message->msg, message->tm, pkt->status, message->utf8);
    13041323                } else if (pkt->status == 0xffffffff) {
    1305                         YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, message->msg, 0, E_SYSTEM);
     1324                        YAHOO_CALLBACK(ext_yahoo_error) (yd->client_id, message->msg, 0, E_SYSTEM);
    13061325                }
    13071326                free(message);
     
    13271346        }
    13281347
    1329         /* Status updates may be spread accross multiple packets and not
    1330            even on buddy boundaries, so keeping some state is important.
    1331            So, continue where we left off, and only add a user entry to
    1332            the list once it's complete (301-315 End buddy). */
     1348        /*
     1349         * Status updates may be spread accross multiple packets and not
     1350         * even on buddy boundaries, so keeping some state is important.
     1351         * So, continue where we left off, and only add a user entry to
     1352         * the list once it's complete (301-315 End buddy).
     1353         */
    13331354        u = yd->half_user;
    13341355
     
    15941615}
    15951616
    1596 static void yahoo_process_verify(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     1617static void yahoo_process_verify(struct yahoo_input_data *yid,
     1618        struct yahoo_packet *pkt)
    15971619{
    15981620        struct yahoo_data *yd = yid->yd;
    15991621
    1600         if(pkt->status != 0x01) {
     1622        if (pkt->status != 0x01) {
    16011623                DEBUG_MSG(("expected status: 0x01, got: %d", pkt->status));
    1602                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_LOCK, "");
    1603                 return;
    1604         }
    1605 
    1606         pkt = yahoo_packet_new(YAHOO_SERVICE_AUTH, YAHOO_STATUS_AVAILABLE, yd->session_id);
     1624                YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id,
     1625                        YAHOO_LOGIN_LOCK, "");
     1626                return;
     1627        }
     1628
     1629        pkt = yahoo_packet_new(YAHOO_SERVICE_AUTH, YPACKET_STATUS_DEFAULT,
     1630                yd->session_id);
    16071631
    16081632        yahoo_packet_hash(pkt, 1, yd->user);
     
    16131637}
    16141638
    1615 static void yahoo_process_picture_checksum( struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     1639static void yahoo_process_picture_checksum(struct yahoo_input_data *yid,
     1640        struct yahoo_packet *pkt)
    16161641{
    16171642        struct yahoo_data *yd = yid->yd;
     
    16211646        YList *l;
    16221647
    1623         for(l = pkt->hash; l; l = l->next)
    1624         {
     1648        for (l = pkt->hash; l; l = l->next) {
    16251649                struct yahoo_pair *pair = l->data;
    16261650
    1627                 switch(pair->key)
    1628                 {
    1629                         case 1:
    1630                         case 4:
    1631                                 from = pair->value;
    1632                         case 5:
    1633                                 to = pair->value;
    1634                                 break;
    1635                         case 212:
    1636                                 break;
    1637                         case 192:
    1638                                 checksum = atoi( pair->value );
    1639                                 break;
    1640                 }
    1641         }
    1642 
    1643         YAHOO_CALLBACK(ext_yahoo_got_buddyicon_checksum)(yd->client_id,to,from,checksum);
    1644 }
    1645 
    1646 static void yahoo_process_picture(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     1651                switch (pair->key) {
     1652                case 1:
     1653                case 4:
     1654                        from = pair->value;
     1655                case 5:
     1656                        to = pair->value;
     1657                        break;
     1658                case 212:
     1659                        break;
     1660                case 192:
     1661                        checksum = atoi(pair->value);
     1662                        break;
     1663                }
     1664        }
     1665
     1666        YAHOO_CALLBACK(ext_yahoo_got_buddyicon_checksum) (yd->client_id, to,
     1667                from, checksum);
     1668}
     1669
     1670static void yahoo_process_picture(struct yahoo_input_data *yid,
     1671        struct yahoo_packet *pkt)
    16471672{
    16481673        struct yahoo_data *yd = yid->yd;
     
    16531678        int checksum = 0;
    16541679        YList *l;
    1655        
    1656         for(l = pkt->hash; l; l = l->next)
    1657         {
     1680
     1681        for (l = pkt->hash; l; l = l->next) {
    16581682                struct yahoo_pair *pair = l->data;
    16591683
    1660                 switch(pair->key)
    1661                 {
     1684                switch (pair->key) {
    16621685                case 1:
    1663                 case 4:         /* sender */
     1686                case 4: /* sender */
    16641687                        from = pair->value;
    16651688                        break;
    1666                 case 5:         /* we */
     1689                case 5: /* we */
    16671690                        to = pair->value;
    16681691                        break;
    1669                 case 13:                /* request / sending */
    1670                         status = atoi( pair->value );
    1671                         break;
    1672                 case 20:                /* url */
     1692                case 13:        /* request / sending */
     1693                        status = atoi(pair->value);
     1694                        break;
     1695                case 20:        /* url */
    16731696                        url = pair->value;
    16741697                        break;
    16751698                case 192:       /*checksum */
    1676                         checksum = atoi( pair->value );
    1677                         break;
    1678                 }
    1679         }
    1680 
    1681         switch( status )
    1682         {
    1683                 case 1: /* this is a request, ignore for now */
    1684                         YAHOO_CALLBACK(ext_yahoo_got_buddyicon_request)(yd->client_id, to, from);
    1685                         break;
    1686                 case 2: /* this is cool - we get a picture :) */
    1687                         YAHOO_CALLBACK(ext_yahoo_got_buddyicon)(yd->client_id,to, from, url, checksum);
    1688                         break;
    1689         }
    1690 }
    1691 
    1692 static void yahoo_process_picture_upload(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     1699                        checksum = atoi(pair->value);
     1700                        break;
     1701                }
     1702        }
     1703
     1704        switch (status) {
     1705        case 1:         /* this is a request, ignore for now */
     1706                YAHOO_CALLBACK(ext_yahoo_got_buddyicon_request) (yd->client_id,
     1707                        to, from);
     1708                break;
     1709        case 2:         /* this is cool - we get a picture :) */
     1710                YAHOO_CALLBACK(ext_yahoo_got_buddyicon) (yd->client_id, to,
     1711                        from, url, checksum);
     1712                break;
     1713        }
     1714}
     1715
     1716static void yahoo_process_picture_upload(struct yahoo_input_data *yid,
     1717        struct yahoo_packet *pkt)
    16931718{
    16941719        struct yahoo_data *yd = yid->yd;
     
    16991724                return;         /* something went wrong */
    17001725       
    1701         for(l = pkt->hash; l; l = l->next)
     1726        for (l = pkt->hash; l; l = l->next)
    17021727        {
    17031728                struct yahoo_pair *pair = l->data;
     
    17171742        }
    17181743
    1719         YAHOO_CALLBACK(ext_yahoo_buddyicon_uploaded)(yd->client_id, url);
     1744        YAHOO_CALLBACK(ext_yahoo_buddyicon_uploaded) (yd->client_id, url);
    17201745}
    17211746
     
    18731898        const unsigned char *magic_ptr;
    18741899
    1875         unsigned int  magic[64];
    1876         unsigned int  magic_work=0;
     1900        unsigned int magic[64];
     1901        unsigned int magic_work = 0;
    18771902
    18781903        char comparison_src[20];
     
    19912016       
    19922017        do {
    1993                 unsigned int     bl = 0; 
    1994                 unsigned int     cl = magic[magic_cnt++];
     2018                unsigned int bl = 0; 
     2019                unsigned int cl = magic[magic_cnt++];
    19952020               
    19962021                if (magic_cnt >= magic_len)
     
    20182043       
    20192044               
    2020         for(x = 0; x < 4; x++)
     2045        for (x = 0; x < 4; x++)
    20212046                magic_key_char[x] = comparison_src[x];
    20222047
     
    20242049        memcpy( chal, magic_key_char, 4 );
    20252050        x = 1;
    2026         for( i = 0; i < 0xFFFF && x; i++ )
     2051        for ( i = 0; i < 0xFFFF && x; i++ )
    20272052        {
    2028                 for( j = 0; j < 5 && x; j++ )
     2053                for ( j = 0; j < 5 && x; j++ )
    20292054                {
    20302055                        chal[4] = i;
     
    20342059                        md5_append( &ctx, chal, 7 );
    20352060                        md5_finish( &ctx, result );
    2036                         if( memcmp( comparison_src + 4, result, 16 ) == 0 )
     2061                        if ( memcmp( comparison_src + 4, result, 16 ) == 0 )
    20372062                        {
    20382063                                depth = i;
     
    21102135
    21112136        for (x = 0; x < 20; x += 2) {
    2112                 unsigned int    val = 0;
    2113                 unsigned int    lookup = 0;
    2114                 char            byte[6];
     2137                unsigned int val = 0;
     2138                unsigned int lookup = 0;
     2139                char byte[6];
    21152140
    21162141                memset(&byte, 0, 6);
     
    23532378       
    23542379        if (req->status_code != 200) {
    2355                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 2000 + req->status_code, NULL);
     2380                YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id, 2000 + req->status_code, NULL);
    23562381                goto fail;
    23572382        }
    23582383       
    23592384        if (sscanf(req->reply_body, "%d", &st) != 1 || st != 0) {
    2360                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, yahoo_https_status_parse(st), NULL);
     2385                YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id, yahoo_https_status_parse(st), NULL);
    23612386                goto fail;
    23622387        }
    23632388       
    23642389        if ((had->token = yahoo_ha_find_key(req->reply_body, "ymsgr")) == NULL) {
    2365                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 3001, NULL);
     2390                YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id, 3001, NULL);
    23662391                goto fail;
    23672392        }
     
    24092434
    24102435        if (req->status_code != 200) {
    2411                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 2000 + req->status_code, NULL);
     2436                YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id, 2000 + req->status_code, NULL);
    24122437                goto fail;
    24132438        }
    24142439       
    24152440        if (sscanf(req->reply_body, "%d", &st) != 1 || st != 0) {
    2416                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, yahoo_https_status_parse(st), NULL);
     2441                YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id, yahoo_https_status_parse(st), NULL);
    24172442                goto fail;
    24182443        }
     
    24212446            (yd->cookie_t = yahoo_ha_find_key(req->reply_body, "T")) == NULL ||
    24222447            (crumb = yahoo_ha_find_key(req->reply_body, "crumb")) == NULL) {
    2423                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 3002, NULL);
     2448                YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id, 3002, NULL);
    24242449                goto fail;
    24252450        }
     
    24982523        char *login_id;
    24992524        char *handle;
    2500         char *url=NULL;
    2501         int  login_status=0;
     2525        char *url = NULL;
     2526        int login_status = 0;
    25022527
    25032528        YList *l;
     
    25152540        }
    25162541
    2517         if(pkt->status == 0xffffffff) {
    2518                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, login_status, url);
     2542        if (pkt->status == 0xffffffff) {
     2543                YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id, login_status, url);
    25192544        /*      yahoo_logoff(yd->client_id);*/
    25202545        }
    25212546}
    25222547
    2523 static void yahoo_process_mail(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     2548static void yahoo_process_mail(struct yahoo_input_data *yid,
     2549        struct yahoo_packet *pkt)
    25242550{
    25252551        struct yahoo_data *yd = yid->yd;
     
    25472573                char from[1024];
    25482574                snprintf(from, sizeof(from), "%s (%s)", who, email);
    2549                 YAHOO_CALLBACK(ext_yahoo_mail_notify)(yd->client_id, from, subj, count);
    2550         } else if(count > 0)
    2551                 YAHOO_CALLBACK(ext_yahoo_mail_notify)(yd->client_id, NULL, NULL, count);
    2552 }
    2553 
    2554 static void yahoo_process_contact(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     2575                YAHOO_CALLBACK(ext_yahoo_mail_notify) (yd->client_id, from,
     2576                        subj, count);
     2577        } else if (count > 0)
     2578                YAHOO_CALLBACK(ext_yahoo_mail_notify) (yd->client_id, NULL,
     2579                        NULL, count);
     2580}
     2581
     2582static void yahoo_process_contact(struct yahoo_input_data *yid,
     2583        struct yahoo_packet *pkt)
    25552584{
    25562585        struct yahoo_data *yd = yid->yd;
     
    25612590        long tm = 0L;
    25622591        int state = YAHOO_STATUS_AVAILABLE;
    2563         int online = FALSE;
     2592        int online = 0;
    25642593        int away = 0;
    25652594        int idle = 0;
     
    25902619                else if (pair->key == 60)
    25912620                        mobile = strtol(pair->value, NULL, 10);
    2592                
     2621
    25932622        }
    25942623
    25952624        if (id)
    2596                 YAHOO_CALLBACK(ext_yahoo_contact_added)(yd->client_id, id, who, msg);
     2625                YAHOO_CALLBACK(ext_yahoo_contact_added) (yd->client_id, id, who,
     2626                        msg);
    25972627        else if (name)
    2598                 YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, name, state, msg, away, idle, mobile);
    2599         else if(pkt->status == 0x07)
    2600                 YAHOO_CALLBACK(ext_yahoo_rejected)(yd->client_id, who, msg);
    2601 }
    2602 
    2603 static void yahoo_process_buddyadd(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     2628                YAHOO_CALLBACK(ext_yahoo_status_changed) (yd->client_id, name,
     2629                        state, msg, away, idle, mobile);
     2630        else if (pkt->status == 0x07)
     2631                YAHOO_CALLBACK(ext_yahoo_rejected) (yd->client_id, who, msg);
     2632}
     2633
     2634static void yahoo_process_buddyadd(struct yahoo_input_data *yid,
     2635        struct yahoo_packet *pkt)
    26042636{
    26052637        struct yahoo_data *yd = yid->yd;
     
    26092641        char *me = NULL;
    26102642
    2611         struct yahoo_buddy *bud=NULL;
     2643        struct yahoo_buddy *bud = NULL;
    26122644
    26132645        YList *l;
     
    26242656        }
    26252657
    2626         yahoo_dump_unhandled(pkt);
    2627 
    2628         if(!who)
    2629                 return;
    2630         if(!where)
     2658        if (!who)
     2659                return;
     2660        if (!where)
    26312661                where = "Unknown";
    26322662
    26332663        /* status: 0 == Successful, 1 == Error (does not exist), 2 == Already in list */
    2634         if( status == 0 ) {
     2664        if ( status == 0 ) {
    26352665                bud = y_new0(struct yahoo_buddy, 1);
    26362666                bud->id = strdup(who);
     
    26422672                /* Possibly called already, but at least the call above doesn't
    26432673                   seem to happen every time (not anytime I tried). */
    2644                 YAHOO_CALLBACK(ext_yahoo_contact_added)(yd->client_id, me, who, NULL);
    2645         }
    2646 
    2647 /*      YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, who, status, NULL, (status==YAHOO_STATUS_AVAILABLE?0:1)); */
     2674                YAHOO_CALLBACK(ext_yahoo_contact_added) (yd->client_id, me, who, NULL);
     2675        }
     2676
     2677/*      YAHOO_CALLBACK(ext_yahoo_status_changed) (yd->client_id, who, status, NULL, (status==YAHOO_STATUS_AVAILABLE?0:1)); */
    26482678}
    26492679
    26502680static void yahoo_process_contact_ymsg13(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
    26512681{
    2652         char* who=NULL;
    2653         char* me=NULL; 
    2654         char* msg=NULL;
     2682        char* who = NULL;
     2683        char* me = NULL;       
     2684        char* msg = NULL;
    26552685        YList *l;
    26562686        for (l = pkt->hash; l; l = l->next) {
     
    26642694        }
    26652695
    2666         if(pkt->status==3)
    2667                 YAHOO_CALLBACK(ext_yahoo_contact_auth_request)(yid->yd->client_id, me, who, msg);
    2668 }
    2669 
    2670 static void yahoo_process_buddydel(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     2696        if (pkt->status==3)
     2697                YAHOO_CALLBACK(ext_yahoo_contact_auth_request) (yid->yd->client_id, me, who, msg);
     2698}
     2699
     2700static void yahoo_process_buddydel(struct yahoo_input_data *yid,
     2701        struct yahoo_packet *pkt)
    26712702{
    26722703        struct yahoo_data *yd = yid->yd;
     
    26912722                        unk_66 = strtol(pair->value, NULL, 10);
    26922723                else
    2693                         DEBUG_MSG(("unknown key: %d = %s", pair->key, pair->value));
    2694         }
    2695 
    2696         if(!who || !where)
    2697                 return;
    2698        
     2724                        DEBUG_MSG(("unknown key: %d = %s", pair->key,
     2725                                        pair->value));
     2726        }
     2727
     2728        if (!who || !where)
     2729                return;
     2730
    26992731        bud = y_new0(struct yahoo_buddy, 1);
    27002732        bud->id = strdup(who);
     
    27072739        FREE(bud);
    27082740
    2709         if(buddy) {
     2741        if (buddy) {
    27102742                bud = buddy->data;
    27112743                yd->buddies = y_list_remove_link(yd->buddies, buddy);
     
    27172749                FREE(bud);
    27182750
    2719                 bud=NULL;
    2720         }
    2721 }
    2722 
    2723 static void yahoo_process_ignore(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     2751                bud = NULL;
     2752        }
     2753}
     2754
     2755static void yahoo_process_ignore(struct yahoo_input_data *yid,
     2756        struct yahoo_packet *pkt)
    27242757{
    27252758        char *who = NULL;
    2726         int  status = 0;
     2759        int status = 0;
    27272760        char *me = NULL;
    2728         int  un_ignore = 0;
     2761        int un_ignore = 0;
    27292762
    27302763        YList *l;
     
    27352768                if (pair->key == 1)
    27362769                        me = pair->value;
    2737                 if (pair->key == 13) /* 1 == ignore, 2 == unignore */
     2770                if (pair->key == 13)    /* 1 == ignore, 2 == unignore */
    27382771                        un_ignore = strtol(pair->value, NULL, 10);
    2739                 if (pair->key == 66) 
     2772                if (pair->key == 66)
    27402773                        status = strtol(pair->value, NULL, 10);
    27412774        }
    2742 
    27432775
    27442776        /*
    27452777         * status
    2746          *      0  - ok
    2747          *      2  - already in ignore list, could not add
    2748          *      3  - not in ignore list, could not delete
    2749          *      12 - is a buddy, could not add
     2778         *      0  - ok
     2779         *      2  - already in ignore list, could not add
     2780         *      3  - not in ignore list, could not delete
     2781         *      12 - is a buddy, could not add
    27502782         */
    27512783
    27522784/*      if(status)
    2753                 YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, who, 0, status);
    2754 */     
    2755 }
    2756 
    2757 static void yahoo_process_voicechat(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     2785                YAHOO_CALLBACK(ext_yahoo_error) (yd->client_id, who, 0, status);
     2786*/
     2787}
     2788
     2789static void yahoo_process_voicechat(struct yahoo_input_data *yid,
     2790        struct yahoo_packet *pkt)
    27582791{
    27592792        char *who = NULL;
     
    27702803                        me = pair->value;
    27712804                if (pair->key == 13)
    2772                         voice_room=pair->value;
    2773                 if (pair->key == 57)
    2774                         room=pair->value;
    2775         }
    2776 
    2777         NOTICE(("got voice chat invite from %s in %s to identity %s", who, room, me));
     2805                        voice_room = pair->value;
     2806                if (pair->key == 57)
     2807                        room = pair->value;
     2808        }
     2809
     2810        NOTICE(("got voice chat invite from %s in %s to identity %s", who, room,
     2811                        me));
    27782812        /*
    27792813         * send: s:0 1:me 5:who 57:room 13:1
     
    27872821}
    27882822
    2789 static void yahoo_process_ping(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     2823static void yahoo_process_ping(struct yahoo_input_data *yid,
     2824        struct yahoo_packet *pkt)
    27902825{
    27912826        char *errormsg = NULL;
    2792        
     2827
    27932828        YList *l;
    27942829        for (l = pkt->hash; l; l = l->next) {
     
    27972832                        errormsg = pair->value;
    27982833        }
    2799        
     2834
    28002835        NOTICE(("got ping packet"));
    2801         YAHOO_CALLBACK(ext_yahoo_got_ping)(yid->yd->client_id, errormsg);
     2836        YAHOO_CALLBACK(ext_yahoo_got_ping) (yid->yd->client_id, errormsg);
    28022837}
    28032838
     
    28082843        char *data = NULL;
    28092844        char *packet = NULL;
    2810         unsigned char magic_nr[] = {0, 1, 0};
     2845        unsigned char magic_nr[] = { 0, 1, 0 };
    28112846        unsigned char header_len = 8;
    28122847        unsigned int len = 0;
    28132848        unsigned int pos = 0;
    28142849
    2815         if(error || fd <= 0) {
     2850        if (error || fd <= 0) {
    28162851                FREE(who);
    28172852                FREE(yid);
     
    28212856        yid->fd = fd;
    28222857        inputs = y_list_prepend(inputs, yid);
    2823        
     2858
    28242859        /* send initial packet */
    28252860        if (who)
     
    28312866
    28322867        /* send data */
    2833         if (who)
    2834         {
     2868        if (who) {
    28352869                data = strdup("g=");
    28362870                data = y_string_append(data, who);
     
    28512885        FREE(data);
    28522886
    2853         yid->read_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, fd, YAHOO_INPUT_READ, yid);
    2854 }
    2855 
    2856 static void yahoo_webcam_get_server(struct yahoo_input_data *y, char *who, char *key)
     2887        yid->read_tag =
     2888                YAHOO_CALLBACK(ext_yahoo_add_handler) (yid->yd->client_id, fd,
     2889                YAHOO_INPUT_READ, yid);
     2890}
     2891
     2892static void yahoo_webcam_get_server(struct yahoo_input_data *y, char *who,
     2893        char *key)
    28572894{
    28582895        struct yahoo_input_data *yid = y_new0(struct yahoo_input_data, 1);
     
    28622899        yid->yd = y->yd;
    28632900        yid->wcm = y_new0(struct yahoo_webcam, 1);
    2864         yid->wcm->user = who?strdup(who):NULL;
    2865         yid->wcm->direction = who?YAHOO_WEBCAM_DOWNLOAD:YAHOO_WEBCAM_UPLOAD;
     2901        yid->wcm->user = who ? strdup(who) : NULL;
     2902        yid->wcm->direction = who ? YAHOO_WEBCAM_DOWNLOAD : YAHOO_WEBCAM_UPLOAD;
    28662903        yid->wcm->key = strdup(key);
    28672904
    2868         YAHOO_CALLBACK(ext_yahoo_connect_async)(yid->yd->client_id, yss->webcam_host, yss->webcam_port,
    2869                         _yahoo_webcam_get_server_connected, yid);
    2870 
    2871 }
    2872 
    2873 static YList *webcam_queue=NULL;
    2874 static void yahoo_process_webcam_key(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     2905        YAHOO_CALLBACK(ext_yahoo_connect_async) (yid->yd->client_id,
     2906                yss->webcam_host, yss->webcam_port,
     2907                _yahoo_webcam_get_server_connected, yid);
     2908
     2909}
     2910
     2911static YList *webcam_queue = NULL;
     2912static void yahoo_process_webcam_key(struct yahoo_input_data *yid,
     2913        struct yahoo_packet *pkt)
    28752914{
    28762915        char *me = NULL;
     
    28792918
    28802919        YList *l;
    2881         // yahoo_dump_unhandled(pkt);
     2920        yahoo_dump_unhandled(pkt);
    28822921        for (l = pkt->hash; l; l = l->next) {
    28832922                struct yahoo_pair *pair = l->data;
    28842923                if (pair->key == 5)
    28852924                        me = pair->value;
    2886                 if (pair->key == 61) 
    2887                         key=pair->value;
     2925                if (pair->key == 61)
     2926                        key = pair->value;
    28882927        }
    28892928
    28902929        l = webcam_queue;
    2891         if(!l)
     2930        if (!l)
    28922931                return;
    28932932        who = l->data;
     
    28982937}
    28992938
    2900 static void yahoo_packet_process(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     2939static void yahoo_packet_process(struct yahoo_input_data *yid,
     2940        struct yahoo_packet *pkt)
    29012941{
    29022942        DEBUG_MSG(("yahoo_packet_process: 0x%02x", pkt->service));
    2903         yahoo_dump_unhandled(pkt);
    2904         switch (pkt->service)
    2905         {
     2943        switch (pkt->service) {
    29062944        case YAHOO_SERVICE_USERSTAT:
    29072945        case YAHOO_SERVICE_LOGON:
     
    30223060}
    30233061
    3024 static struct yahoo_packet * yahoo_getdata(struct yahoo_input_data * yid)
     3062static struct yahoo_packet *yahoo_getdata(struct yahoo_input_data *yid)
    30253063{
    30263064        struct yahoo_packet *pkt;
     
    30293067        int pktlen;
    30303068
    3031         if(!yd)
     3069        if (!yd)
    30323070                return NULL;
    30333071
     
    30383076        }
    30393077
    3040         pos += 4; /* YMSG */
     3078        pos += 4;               /* YMSG */
    30413079        pos += 2;
    30423080        pos += 2;
    30433081
    3044         pktlen = yahoo_get16(yid->rxqueue + pos); pos += 2;
    3045         DEBUG_MSG(("%d bytes to read, rxlen is %d",
    3046                         pktlen, yid->rxlen));
     3082        pktlen = yahoo_get16(yid->rxqueue + pos);
     3083        pos += 2;
     3084        DEBUG_MSG(("%d bytes to read, rxlen is %d", pktlen, yid->rxlen));
    30473085
    30483086        if (yid->rxlen < (YAHOO_PACKET_HDRLEN + pktlen)) {
     
    30563094        pkt = yahoo_packet_new(0, 0, 0);
    30573095
    3058         pkt->service = yahoo_get16(yid->rxqueue + pos); pos += 2;
    3059         pkt->status = yahoo_get32(yid->rxqueue + pos); pos += 4;
     3096        pkt->service = yahoo_get16(yid->rxqueue + pos);
     3097        pos += 2;
     3098        pkt->status = yahoo_get32(yid->rxqueue + pos);
     3099        pos += 4;
    30603100        DEBUG_MSG(("Yahoo Service: 0x%02x Status: %d", pkt->service,
    3061                                 pkt->status));
    3062         pkt->id = yahoo_get32(yid->rxqueue + pos); pos += 4;
     3101                        pkt->status));
     3102        pkt->id = yahoo_get32(yid->rxqueue + pos);
     3103        pos += 4;
    30633104
    30643105        yd->session_id = pkt->id;
     
    30683109        yid->rxlen -= YAHOO_PACKET_HDRLEN + pktlen;
    30693110        DEBUG_MSG(("rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
    3070         if (yid->rxlen>0) {
    3071                 unsigned char *tmp = y_memdup(yid->rxqueue + YAHOO_PACKET_HDRLEN 
    3072                                 + pktlen, yid->rxlen);
     3111        if (yid->rxlen > 0) {
     3112                unsigned char *tmp = y_memdup(yid->rxqueue + YAHOO_PACKET_HDRLEN
     3113                        + pktlen, yid->rxlen);
    30733114                FREE(yid->rxqueue);
    30743115                yid->rxqueue = tmp;
    3075                 DEBUG_MSG(("new rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
     3116                DEBUG_MSG(("new rxlen == %d, rxqueue == %p", yid->rxlen,
     3117                                yid->rxqueue));
    30763118        } else {
    30773119                DEBUG_MSG(("freed rxqueue == %p", yid->rxqueue));
     
    30823124}
    30833125
    3084 static void yahoo_yab_read(struct yab *yab, unsigned char *d, int len)
     3126static struct yab *yahoo_yab_read(unsigned char *d, int len)
    30853127{
    30863128        char *st, *en;
    30873129        char *data = (char *)d;
    3088         data[len]='\0';
     3130        struct yab *yab = NULL;
     3131
     3132        data[len] = '\0';
    30893133
    30903134        DEBUG_MSG(("Got yab: %s", data));
    3091         st = en = strstr(data, "userid=\"");
    3092         if(st) {
    3093                 st += strlen("userid=\"");
    3094                 en = strchr(st, '"'); *en++ = '\0';
     3135        st = en = strstr(data, "e0=\"");
     3136        if (st) {
     3137                yab = y_new0(struct yab, 1);
     3138
     3139                st += strlen("e0=\"");
     3140                en = strchr(st, '"');
     3141                *en++ = '\0';
     3142                yab->email = yahoo_xmldecode(st);
     3143        }
     3144
     3145        if (!en)
     3146                return NULL;
     3147
     3148        st = strstr(en, "id=\"");
     3149        if (st) {
     3150                st += strlen("id=\"");
     3151                en = strchr(st, '"');
     3152                *en++ = '\0';
     3153                yab->yid = atoi(yahoo_xmldecode(st));
     3154        }
     3155
     3156        st = strstr(en, "fn=\"");
     3157        if (st) {
     3158                st += strlen("fn=\"");
     3159                en = strchr(st, '"');
     3160                *en++ = '\0';
     3161                yab->fname = yahoo_xmldecode(st);
     3162        }
     3163
     3164        st = strstr(en, "ln=\"");
     3165        if (st) {
     3166                st += strlen("ln=\"");
     3167                en = strchr(st, '"');
     3168                *en++ = '\0';
     3169                yab->lname = yahoo_xmldecode(st);
     3170        }
     3171
     3172        st = strstr(en, "nn=\"");
     3173        if (st) {
     3174                st += strlen("nn=\"");
     3175                en = strchr(st, '"');
     3176                *en++ = '\0';
     3177                yab->nname = yahoo_xmldecode(st);
     3178        }
     3179
     3180        st = strstr(en, "yi=\"");
     3181        if (st) {
     3182                st += strlen("yi=\"");
     3183                en = strchr(st, '"');
     3184                *en++ = '\0';
    30953185                yab->id = yahoo_xmldecode(st);
    30963186        }
    30973187
    3098         st = strstr(en, "fname=\"");
    3099         if(st) {
    3100                 st += strlen("fname=\"");
    3101                 en = strchr(st, '"'); *en++ = '\0';
    3102                 yab->fname = yahoo_xmldecode(st);
    3103         }
    3104 
    3105         st = strstr(en, "lname=\"");
    3106         if(st) {
    3107                 st += strlen("lname=\"");
    3108                 en = strchr(st, '"'); *en++ = '\0';
    3109                 yab->lname = yahoo_xmldecode(st);
    3110         }
    3111 
    3112         st = strstr(en, "nname=\"");
    3113         if(st) {
    3114                 st += strlen("nname=\"");
    3115                 en = strchr(st, '"'); *en++ = '\0';
    3116                 yab->nname = yahoo_xmldecode(st);
    3117         }
    3118 
    3119         st = strstr(en, "email=\"");
    3120         if(st) {
    3121                 st += strlen("email=\"");
    3122                 en = strchr(st, '"'); *en++ = '\0';
    3123                 yab->email = yahoo_xmldecode(st);
    3124         }
    3125 
    31263188        st = strstr(en, "hphone=\"");
    3127         if(st) {
     3189        if (st) {
    31283190                st += strlen("hphone=\"");
    3129                 en = strchr(st, '"'); *en++ = '\0';
     3191                en = strchr(st, '"');
     3192                *en++ = '\0';
    31303193                yab->hphone = yahoo_xmldecode(st);
    31313194        }
    31323195
    31333196        st = strstr(en, "wphone=\"");
    3134         if(st) {
     3197        if (st) {
    31353198                st += strlen("wphone=\"");
    3136                 en = strchr(st, '"'); *en++ = '\0';
     3199                en = strchr(st, '"');
     3200                *en++ = '\0';
    31373201                yab->wphone = yahoo_xmldecode(st);
    31383202        }
    31393203
    31403204        st = strstr(en, "mphone=\"");
    3141         if(st) {
     3205        if (st) {
    31423206                st += strlen("mphone=\"");
    3143                 en = strchr(st, '"'); *en++ = '\0';
     3207                en = strchr(st, '"');
     3208                *en++ = '\0';
    31443209                yab->mphone = yahoo_xmldecode(st);
    31453210        }
    31463211
    31473212        st = strstr(en, "dbid=\"");
    3148         if(st) {
     3213        if (st) {
    31493214                st += strlen("dbid=\"");
    3150                 en = strchr(st, '"'); *en++ = '\0';
     3215                en = strchr(st, '"');
     3216                *en++ = '\0';
    31513217                yab->dbid = atoi(st);
    31523218        }
    3153 }
    3154 
    3155 static struct yab * yahoo_getyab(struct yahoo_input_data *yid)
     3219
     3220        return yab;
     3221}
     3222
     3223static struct yab *yahoo_getyab(struct yahoo_input_data *yid)
    31563224{
    31573225        struct yab *yab = NULL;
    3158         int pos = 0, end=0;
     3226        int pos = 0, end = 0;
    31593227        struct yahoo_data *yd = yid->yd;
    31603228
    3161         if(!yd)
     3229        if (!yd)
    31623230                return NULL;
    31633231
     3232        do {
     3233                DEBUG_MSG(("rxlen is %d", yid->rxlen));
     3234
     3235                if (yid->rxlen <= strlen("<ct"))
     3236                        return NULL;
     3237
     3238                /* start with <ct */
     3239                while (pos < yid->rxlen - strlen("<ct") + 1
     3240                        && memcmp(yid->rxqueue + pos, "<ct", strlen("<ct")))
     3241                        pos++;
     3242
     3243                if (pos >= yid->rxlen - 1)
     3244                        return NULL;
     3245
     3246                end = pos + 2;
     3247                /* end with > */
     3248                while (end < yid->rxlen - strlen(">")
     3249                        && memcmp(yid->rxqueue + end, ">", strlen(">")))
     3250                        end++;
     3251
     3252                if (end >= yid->rxlen - 1)
     3253                        return NULL;
     3254
     3255                yab = yahoo_yab_read(yid->rxqueue + pos, end + 2 - pos);
     3256
     3257                yid->rxlen -= end + 1;
     3258                DEBUG_MSG(("rxlen == %d, rxqueue == %p", yid->rxlen,
     3259                                yid->rxqueue));
     3260                if (yid->rxlen > 0) {
     3261                        unsigned char *tmp =
     3262                                y_memdup(yid->rxqueue + end + 1, yid->rxlen);
     3263                        FREE(yid->rxqueue);
     3264                        yid->rxqueue = tmp;
     3265                        DEBUG_MSG(("new rxlen == %d, rxqueue == %p", yid->rxlen,
     3266                                        yid->rxqueue));
     3267                } else {
     3268                        DEBUG_MSG(("freed rxqueue == %p", yid->rxqueue));
     3269                        FREE(yid->rxqueue);
     3270                }
     3271
     3272        } while (!yab && end < yid->rxlen - 1);
     3273
     3274        return yab;
     3275}
     3276
     3277static char *yahoo_getwebcam_master(struct yahoo_input_data *yid)
     3278{
     3279        unsigned int pos = 0;
     3280        unsigned int len = 0;
     3281        unsigned int status = 0;
     3282        char *server = NULL;
     3283        struct yahoo_data *yd = yid->yd;
     3284
     3285        if (!yid || !yd)
     3286                return NULL;
     3287
    31643288        DEBUG_MSG(("rxlen is %d", yid->rxlen));
    31653289
    3166         if(yid->rxlen <= strlen("<record"))
     3290        len = yid->rxqueue[pos++];
     3291        if (yid->rxlen < len)
    31673292                return NULL;
    31683293
    3169         /* start with <record */
    3170         while(pos < yid->rxlen-strlen("<record")+1
    3171                         && memcmp(yid->rxqueue + pos, "<record", strlen("<record")))
    3172                 pos++;
    3173 
    3174         if(pos >= yid->rxlen-1)
    3175                 return NULL;
    3176 
    3177         end = pos+2;
    3178         /* end with /> */
    3179         while(end < yid->rxlen-strlen("/>")+1 && memcmp(yid->rxqueue + end, "/>", strlen("/>")))
    3180                 end++;
    3181 
    3182         if(end >= yid->rxlen-1)
    3183                 return NULL;
    3184 
    3185         yab = y_new0(struct yab, 1);
    3186         yahoo_yab_read(yab, yid->rxqueue + pos, end+2-pos);
    3187        
    3188 
    3189         yid->rxlen -= end+1;
     3294        /* extract status (0 = ok, 6 = webcam not online) */
     3295        status = yid->rxqueue[pos++];
     3296
     3297        if (status == 0) {
     3298                pos += 2;       /* skip next 2 bytes */
     3299                server = y_memdup(yid->rxqueue + pos, 16);
     3300                pos += 16;
     3301        } else if (status == 6) {
     3302                YAHOO_CALLBACK(ext_yahoo_webcam_closed)
     3303                        (yd->client_id, yid->wcm->user, 4);
     3304        }
     3305
     3306        /* skip rest of the data */
     3307
     3308        yid->rxlen -= len;
    31903309        DEBUG_MSG(("rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
    3191         if (yid->rxlen>0) {
    3192                 unsigned char *tmp = y_memdup(yid->rxqueue + end + 1, yid->rxlen);
     3310        if (yid->rxlen > 0) {
     3311                unsigned char *tmp = y_memdup(yid->rxqueue + pos, yid->rxlen);
    31933312                FREE(yid->rxqueue);
    31943313                yid->rxqueue = tmp;
    3195                 DEBUG_MSG(("new rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
     3314                DEBUG_MSG(("new rxlen == %d, rxqueue == %p", yid->rxlen,
     3315                                yid->rxqueue));
    31963316        } else {
    31973317                DEBUG_MSG(("freed rxqueue == %p", yid->rxqueue));
     
    31993319        }
    32003320
    3201 
    3202         return yab;
    3203 }
    3204 
    3205 static char * yahoo_getwebcam_master(struct yahoo_input_data *yid)
    3206 {
    3207         unsigned int pos=0;
    3208         unsigned int len=0;
    3209         unsigned int status=0;
    3210         char *server=NULL;
     3321        return server;
     3322}
     3323
     3324static int yahoo_get_webcam_data(struct yahoo_input_data *yid)
     3325{
     3326        unsigned char reason = 0;
     3327        unsigned int pos = 0;
     3328        unsigned int begin = 0;
     3329        unsigned int end = 0;
     3330        unsigned int closed = 0;
     3331        unsigned char header_len = 0;
     3332        char *who;
     3333        int connect = 0;
    32113334        struct yahoo_data *yd = yid->yd;
    32123335
    3213         if(!yid || !yd)
    3214                 return NULL;
     3336        if (!yd)
     3337                return -1;
     3338
     3339        if (!yid->wcm || !yid->wcd || !yid->rxlen)
     3340                return -1;
    32153341
    32163342        DEBUG_MSG(("rxlen is %d", yid->rxlen));
    32173343
    3218         len = yid->rxqueue[pos++];
    3219         if (yid->rxlen < len)
    3220                 return NULL;
    3221 
    3222         /* extract status (0 = ok, 6 = webcam not online) */
    3223         status = yid->rxqueue[pos++];
    3224 
    3225         if (status == 0)
    3226         {
    3227                 pos += 2; /* skip next 2 bytes */
    3228                 server =  y_memdup(yid->rxqueue+pos, 16);
    3229                 pos += 16;
    3230         }
    3231         else if (status == 6)
    3232         {
    3233                 YAHOO_CALLBACK(ext_yahoo_webcam_closed)
    3234                         (yd->client_id, yid->wcm->user, 4);
    3235         }
    3236 
    3237         /* skip rest of the data */
    3238 
    3239         yid->rxlen -= len;
    3240         DEBUG_MSG(("rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
    3241         if (yid->rxlen>0) {
    3242                 unsigned char *tmp = y_memdup(yid->rxqueue + pos, yid->rxlen);
    3243                 FREE(yid->rxqueue);
    3244                 yid->rxqueue = tmp;
    3245                 DEBUG_MSG(("new rxlen == %d, rxqueue == %p", yid->rxlen, yid->rxqueue));
    3246         } else {
    3247                 DEBUG_MSG(("freed rxqueue == %p", yid->rxqueue));
    3248                 FREE(yid->rxqueue);
    3249         }
    3250 
    3251         return server;
    3252 }
    3253 
    3254 static int yahoo_get_webcam_data(struct yahoo_input_data *yid)
    3255 {
    3256         unsigned char reason=0;
    3257         unsigned int pos=0;
    3258         unsigned int begin=0;
    3259         unsigned int end=0;
    3260         unsigned int closed=0;
    3261         unsigned char header_len=0;
    3262         char *who;
    3263         int connect=0;
    3264         struct yahoo_data *yd = yid->yd;
    3265 
    3266         if(!yd)
    3267                 return -1;
    3268 
    3269         if(!yid->wcm || !yid->wcd || !yid->rxlen)
    3270                 return -1;
    3271 
    3272         DEBUG_MSG(("rxlen is %d", yid->rxlen));
    3273 
    32743344        /* if we are not reading part of image then read header */
    3275         if (!yid->wcd->to_read)
    3276         {
    3277                 header_len=yid->rxqueue[pos++];
    3278                 yid->wcd->packet_type=0;
     3345        if (!yid->wcd->to_read) {
     3346                header_len = yid->rxqueue[pos++];
     3347                yid->wcd->packet_type = 0;
    32793348
    32803349                if (yid->rxlen < header_len)
    32813350                        return 0;
    32823351
    3283                 if (header_len >= 8)
    3284                 {
     3352                if (header_len >= 8) {
    32853353                        reason = yid->rxqueue[pos++];
    32863354                        /* next 2 bytes should always be 05 00 */
     
    32903358                        yid->wcd->to_read = yid->wcd->data_size;
    32913359                }
    3292                 if (header_len >= 13)
    3293                 {
     3360                if (header_len >= 13) {
    32943361                        yid->wcd->packet_type = yid->rxqueue[pos++];
    32953362                        yid->wcd->timestamp = yahoo_get32(yid->rxqueue + pos);
     
    33033370        begin = pos;
    33043371        pos += yid->wcd->to_read;
    3305         if (pos > yid->rxlen) pos = yid->rxlen;
     3372        if (pos > yid->rxlen)
     3373                pos = yid->rxlen;
    33063374
    33073375        /* if it is not an image then make sure we have the whole packet */
     
    33163384
    33173385        DEBUG_MSG(("packet type %.2X, data length %d", yid->wcd->packet_type,
    3318                 yid->wcd->data_size));
     3386                        yid->wcd->data_size));
    33193387
    33203388        /* find out what kind of packet we got */
     
    33323400                                        who = y_memdup(yid->rxqueue + begin, end - begin);
    33333401                                        who[end - begin - 1] = 0;
    3334                                         YAHOO_CALLBACK(ext_yahoo_webcam_viewer)(yd->client_id, who + 2, 2);
     3402                                        YAHOO_CALLBACK(ext_yahoo_webcam_viewer) (yd->client_id, who + 2, 2);
    33353403                                        FREE(who);
    33363404                                }
     
    33423410                                /* 1 = accepted viewing permission */
    33433411                                if (yid->wcd->timestamp == 0) {
    3344                                         YAHOO_CALLBACK(ext_yahoo_webcam_closed)(yd->client_id, yid->wcm->user, 3);
     3412                                        YAHOO_CALLBACK(ext_yahoo_webcam_closed) (yd->client_id, yid->wcm->user, 3);
    33453413                                }
    33463414                        }
     
    33513419                        break;
    33523420                case 0x02: /* image data */
    3353                         YAHOO_CALLBACK(ext_yahoo_got_webcam_image)(yd->client_id,
     3421                        YAHOO_CALLBACK(ext_yahoo_got_webcam_image) (yd->client_id,
    33543422                                        yid->wcm->user, yid->rxqueue + begin,
    33553423                                        yid->wcd->data_size, pos - begin,
     
    33583426                case 0x05: /* response packets when uploading */
    33593427                        if (!yid->wcd->data_size) {
    3360                                 YAHOO_CALLBACK(ext_yahoo_webcam_data_request)(yd->client_id, yid->wcd->timestamp);
     3428                                YAHOO_CALLBACK(ext_yahoo_webcam_data_request) (yd->client_id, yid->wcd->timestamp);
    33613429                        }
    33623430                        break;
     
    33713439                                        break;
    33723440                        }
    3373                         YAHOO_CALLBACK(ext_yahoo_webcam_closed)(yd->client_id, yid->wcm->user, closed);
     3441                        YAHOO_CALLBACK(ext_yahoo_webcam_closed) (yd->client_id, yid->wcm->user, closed);
    33743442                        break;
    33753443                case 0x0C: /* user connected */
     
    33793447                                who[pos - begin] = 0;
    33803448                                if (yid->wcd->packet_type == 0x0C)
    3381                                         connect=1;
     3449                                        connect = 1;
    33823450                                else
    3383                                         connect=0;
    3384                                 YAHOO_CALLBACK(ext_yahoo_webcam_viewer)(yd->client_id, who, connect);
     3451                                        connect = 0;
     3452                                YAHOO_CALLBACK(ext_yahoo_webcam_viewer) (yd->client_id, who, connect);
    33853453                                FREE(who);
    33863454                        }
    33873455                        break;
    33883456                case 0x13: /* user data */
    3389                         /* i=user_ip (ip of the user we are viewing) */
    3390                         /* j=user_ext_ip (external ip of the user we */
     3457                        /* i = user_ip (ip of the user we are viewing) */
     3458                        /* j = user_ext_ip (external ip of the user we */
    33913459                        /*                are viewing) */
    33923460                        break;
     
    34223490
    34233491        LOG(("write callback: id=%d fd=%d data=%p", id, fd, data));
    3424         if(!yid || !yid->txqueues || !find_conn_by_id(id))
     3492        if (!yid || !yid->txqueues || !find_conn_by_id(id))
    34253493                return -2;
    34263494       
     
    34293497        len = yahoo_send_data(fd, tx->queue, MIN(1024, tx->len));
    34303498
    3431         if(len == -1 && errno == EAGAIN)
     3499        if (len == -1 && errno == EAGAIN)
    34323500                return 1;
    34333501
    3434         if(len <= 0) {
     3502        if (len <= 0) {
    34353503                int e = errno;
    34363504                DEBUG_MSG(("len == %d (<= 0)", len));
    3437                 while(yid->txqueues) {
    3438                         YList *l=yid->txqueues;
     3505                while (yid->txqueues) {
     3506                        YList *l = yid->txqueues;
    34393507                        tx = l->data;
    34403508                        free(tx->queue);
     
    34443512                }
    34453513                LOG(("yahoo_write_ready(%d, %d) len < 0", id, fd));
    3446                 YAHOO_CALLBACK(ext_yahoo_remove_handler)(id, yid->write_tag);
     3514                YAHOO_CALLBACK(ext_yahoo_remove_handler) (id, yid->write_tag);
    34473515                yid->write_tag = 0;
    3448                 errno=e;
     3516                errno = e;
    34493517                return 0;
    34503518        }
     
    34523520
    34533521        tx->len -= len;
    3454         if(tx->len > 0) {
     3522        if (tx->len > 0) {
    34553523                unsigned char *tmp = y_memdup(tx->queue + len, tx->len);
    34563524                FREE(tx->queue);
    34573525                tx->queue = tmp;
    34583526        } else {
    3459                 YList *l=yid->txqueues;
     3527                YList *l = yid->txqueues;
    34603528                free(tx->queue);
    34613529                free(tx);
     
    34633531                y_list_free_1(l);
    34643532                /*
    3465                 if(!yid->txqueues)
     3533                if (!yid->txqueues)
    34663534                        LOG(("yahoo_write_ready(%d, %d) !yxqueues", id, fd));
    34673535                */
    3468                 if(!yid->txqueues) {
     3536                if (!yid->txqueues) {
    34693537                        LOG(("yahoo_write_ready(%d, %d) !yxqueues", id, fd));
    3470                         YAHOO_CALLBACK(ext_yahoo_remove_handler)(id, yid->write_tag);
     3538                        YAHOO_CALLBACK(ext_yahoo_remove_handler) (id, yid->write_tag);
    34713539                        yid->write_tag = 0;
    34723540                }
     
    34823550        int id = yd->client_id;
    34833551
    3484         if(over)
     3552        if (over)
    34853553                return;
    34863554
     
    35003568static void yahoo_process_chatcat_connection(struct yahoo_input_data *yid, int over)
    35013569{
    3502         if(over)
     3570        if (over)
    35033571                return;
    35043572
    35053573        if (strstr((char*)yid->rxqueue+(yid->rxlen-20), "</content>")) {
    3506                 YAHOO_CALLBACK(ext_yahoo_chat_cat_xml)(yid->yd->client_id, (char*)yid->rxqueue);
     3574                YAHOO_CALLBACK(ext_yahoo_chat_cat_xml) (yid->yd->client_id, (char*)yid->rxqueue);
    35073575        }
    35083576}
     
    35133581        struct yab *yab;
    35143582        YList *buds;
    3515         int changed=0;
     3583        int changed = 0;
    35163584        int id = yd->client_id;
    35173585
    3518         if(over)
    3519                 return;
    3520 
    3521         while(find_input_by_id_and_type(id, YAHOO_CONNECTION_YAB)
     3586        if (over)
     3587                return;
     3588
     3589        while (find_input_by_id_and_type(id, YAHOO_CONNECTION_YAB)
    35223590                        && (yab = yahoo_getyab(yid)) != NULL) {
    3523                 if(!yab->id)
     3591                if (!yab->id)
    35243592                        continue;
    3525                 changed=1;
    3526                 for(buds = yd->buddies; buds; buds=buds->next) {
    3527                         struct yahoo_buddy * bud = buds->data;
    3528                         if(!strcmp(bud->id, yab->id)) {
     3593                changed = 1;
     3594                for (buds = yd->buddies; buds; buds = buds->next) {
     3595                        struct yahoo_buddy *bud = buds->data;
     3596                        if (!strcmp(bud->id, yab->id)) {
    35293597                                bud->yab_entry = yab;
    3530                                 if(yab->nname) {
     3598                                if (yab->nname) {
    35313599                                        bud->real_name = strdup(yab->nname);
    3532                                 } else if(yab->fname && yab->lname) {
     3600                                } else if (yab->fname && yab->lname) {
    35333601                                        bud->real_name = y_new0(char,
    35343602                                                        strlen(yab->fname)+
     
    35373605                                        sprintf(bud->real_name, "%s %s",
    35383606                                                        yab->fname, yab->lname);
    3539                                 } else if(yab->fname) {
     3607                                } else if (yab->fname) {
    35403608                                        bud->real_name = strdup(yab->fname);
    35413609                                }
     
    35453613        }
    35463614
    3547         if(changed)
    3548                 YAHOO_CALLBACK(ext_yahoo_got_buddies)(yd->client_id, yd->buddies);
     3615        if (changed)
     3616                YAHOO_CALLBACK(ext_yahoo_got_buddies) (yd->client_id, yd->buddies);
    35493617}
    35503618
    35513619static void yahoo_process_search_connection(struct yahoo_input_data *yid, int over)
    35523620{
    3553         struct yahoo_found_contact *yct=NULL;
     3621        struct yahoo_found_contact *yct = NULL;
    35543622        char *p = (char *)yid->rxqueue, *np, *cp;
    35553623        int k, n;
    3556         int start=0, found=0, total=0;
    3557         YList *contacts=NULL;
     3624        int start = 0, found=0, total=0;
     3625        YList *contacts = NULL;
    35583626        struct yahoo_input_data *pyid = find_input_by_id_and_type(yid->yd->client_id, YAHOO_CONNECTION_PAGER);
    35593627
    3560         if(!over || !pyid)
    3561                 return;
    3562 
    3563         if(p && (p=strstr(p, "\r\n\r\n"))) {
     3628        if (!over || !pyid)
     3629                return;
     3630
     3631        if (p && (p = strstr(p, "\r\n\r\n"))) {
    35643632                p += 4;
    35653633
    3566                 for(k = 0; (p = strchr(p, 4)) && (k < 4); k++) {
     3634                for (k = 0; (p = strchr(p, 4)) && (k < 4); k++) {
    35673635                        p++;
    35683636                        n = atoi(p);
     
    35743642                }
    35753643
    3576                 if(p)
     3644                if (p)
    35773645                        p++;
    35783646
    3579                 k=0;
    3580                 while(p && *p) {
     3647                k = 0;
     3648                while (p && *p) {
    35813649                        cp = p;
    35823650                        np = strchr(p, 4);
    35833651
    3584                         if(!np)
     3652                        if (!np)
    35853653                                break;
    35863654                        *np = 0;
     
    35893657                        switch(k++) {
    35903658                                case 1:
    3591                                         if(strlen(cp) > 2 && y_list_length(contacts) < total) {
     3659                                        if (strlen(cp) > 2 && y_list_length(contacts) < total) {
    35923660                                                yct = y_new0(struct yahoo_found_contact, 1);
    35933661                                                contacts = y_list_append(contacts, yct);
     
    36073675                                        break;
    36083676                                case 5:
    3609                                         if(strcmp(cp, "5") != 0)
     3677                                        if (strcmp(cp, "5") != 0)
    36103678                                                yct->location = cp;
    36113679                                        k = 0;
     
    36153683        }
    36163684
    3617         YAHOO_CALLBACK(ext_yahoo_got_search_result)(yid->yd->client_id, found, start, total, contacts);
    3618 
    3619         while(contacts) {
     3685        YAHOO_CALLBACK(ext_yahoo_got_search_result) (yid->yd->client_id, found, start, total, contacts);
     3686
     3687        while (contacts) {
    36203688                YList *node = contacts;
    36213689                contacts = y_list_remove_link(contacts, node);
     
    36313699        struct yahoo_data *yd = yid->yd;
    36323700        char conn_type[100];
    3633         char *data=NULL;
    3634         char *packet=NULL;
     3701        char *data = NULL;
     3702        char *packet = NULL;
    36353703        unsigned char magic_nr[] = {1, 0, 0, 0, 1};
    3636         unsigned header_len=0;
    3637         unsigned int len=0;
    3638         unsigned int pos=0;
    3639 
    3640         if(error || fd <= 0) {
     3704        unsigned header_len = 0;
     3705        unsigned int len = 0;
     3706        unsigned int pos = 0;
     3707
     3708        if (error || fd <= 0) {
    36413709                FREE(yid);
    36423710                return;
     
    37243792        FREE(data);
    37253793
    3726         yid->read_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, yid->fd, YAHOO_INPUT_READ, yid);
     3794        yid->read_tag = YAHOO_CALLBACK(ext_yahoo_add_handler) (yid->yd->client_id, yid->fd, YAHOO_INPUT_READ, yid);
    37273795}
    37283796
     
    37493817
    37503818        LOG(("Connecting to: %s:%d", wcm->server, wcm->port));
    3751         YAHOO_CALLBACK(ext_yahoo_connect_async)(y->yd->client_id, wcm->server, wcm->port,
     3819        YAHOO_CALLBACK(ext_yahoo_connect_async) (y->yd->client_id, wcm->server, wcm->port,
    37523820                        _yahoo_webcam_connected, yid);
    37533821
     
    37593827        struct yahoo_server_settings *yss;
    37603828
    3761         if(over)
     3829        if (over)
    37623830                return;
    37633831
     
    37833851        int fd = yid->fd;
    37843852
    3785         if(over)
     3853        if (over)
    37863854                return;
    37873855
     
    38083876
    38093877        LOG(("read callback: id=%d fd=%d data=%p", id, fd, data));
    3810         if(!yid)
     3878        if (!yid)
    38113879                return -2;
    38123880
     
    38143882        do {
    38153883                len = read(fd, buf, sizeof(buf));
    3816         } while(len == -1 && errno == EINTR);
    3817 
    3818         if(len == -1 && (errno == EAGAIN||errno == EINTR))      /* we'll try again later */
     3884        } while (len == -1 && errno == EINTR);
     3885
     3886        if (len == -1 && (errno == EAGAIN||errno == EINTR))     /* we'll try again later */
    38193887                return 1;
    38203888
     
    38233891                DEBUG_MSG(("len == %d (<= 0)", len));
    38243892
    3825                 if(yid->type == YAHOO_CONNECTION_PAGER) {
    3826                         YAHOO_CALLBACK(ext_yahoo_error)(yid->yd->client_id, "Connection closed by server", 1, E_CONNECTION);
     3893                if (yid->type == YAHOO_CONNECTION_PAGER) {
     3894                        YAHOO_CALLBACK(ext_yahoo_error) (yid->yd->client_id, "Connection closed by server", 1, E_CONNECTION);
    38273895                }
    38283896
     
    38313899
    38323900                /* no need to return an error, because we've already fixed it */
    3833                 if(len == 0)
     3901                if (len == 0)
    38343902                        return 1;
    38353903
    3836                 errno=e;
     3904                errno = e;
    38373905                LOG(("read error: %s", strerror(errno)));
    38383906                return -1;
     
    38553923        yd = y_new0(struct yahoo_data, 1);
    38563924
    3857         if(!yd)
     3925        if (!yd)
    38583926                return 0;
    38593927
     
    38943962        struct yahoo_server_settings *yss = yd->server_settings;
    38953963
    3896         if(error) {
    3897                 if(fallback_ports[ccd->i]) {
     3964        if (error) {
     3965                if (fallback_ports[ccd->i]) {
    38983966                        int tag;
    38993967                        yss->pager_port = fallback_ports[ccd->i++];
    3900                         tag = YAHOO_CALLBACK(ext_yahoo_connect_async)(yd->client_id, yss->pager_host,
     3968                        tag = YAHOO_CALLBACK(ext_yahoo_connect_async) (yd->client_id, yss->pager_host,
    39013969                                        yss->pager_port, yahoo_connected, ccd);
    39023970
    3903                         if(tag > 0)
    3904                                 ccd->tag=tag;
     3971                        if (tag > 0)
     3972                                ccd->tag = tag;
    39053973                } else {
    39063974                        FREE(ccd);
    3907                         YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_SOCK, NULL);
     3975                        YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id, YAHOO_LOGIN_SOCK, NULL);
    39083976                }
    39093977                return;
     
    39133981
    39143982        /* fd < 0 && error == 0 means connect was cancelled */
    3915         if(fd < 0)
     3983        if (fd < 0)
    39163984                return;
    39173985
     
    39303998        yahoo_packet_free(pkt);
    39313999
    3932         yid->read_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, yid->fd, YAHOO_INPUT_READ, yid);
     4000        yid->read_tag = YAHOO_CALLBACK(ext_yahoo_add_handler) (yid->yd->client_id, yid->fd, YAHOO_INPUT_READ, yid);
    39334001}
    39344002
     
    39404008        int tag;
    39414009
    3942         if(!yd)
     4010        if (!yd)
    39434011                return;
    39444012
     
    39494017        ccd = y_new0(struct connect_callback_data, 1);
    39504018        ccd->yd = yd;
    3951         tag = YAHOO_CALLBACK(ext_yahoo_connect_async)(yd->client_id, yss->pager_host, yss->pager_port,
     4019        tag = YAHOO_CALLBACK(ext_yahoo_connect_async) (yd->client_id, yss->pager_host, yss->pager_port,
    39524020                        yahoo_connected, ccd);
    39534021
     
    39564024         * so ccd will have been freed
    39574025         */
    3958         if(tag > 0)
     4026        if (tag > 0)
    39594027                ccd->tag = tag;
    3960         else if(tag < 0)
    3961                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_SOCK, NULL);
     4028        else if (tag < 0)
     4029                YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id, YAHOO_LOGIN_SOCK, NULL);
    39624030}
    39634031
     
    39664034{
    39674035        struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
    3968         if(!yid)
     4036        if (!yid)
    39694037                return 0;
    39704038        else
     
    39794047        char pic_str[10];
    39804048
    3981         if(!yid)
     4049        if (!yid)
    39824050                return;
    39834051
     
    39884056        snprintf(pic_str, sizeof(pic_str), "%d", picture);
    39894057       
    3990         if(from && strcmp(from, yd->user))
     4058        if (from && strcmp(from, yd->user))
    39914059                yahoo_packet_hash(pkt, 0, yd->user);
    39924060        yahoo_packet_hash(pkt, 1, from?from:yd->user);
     
    39944062        yahoo_packet_hash(pkt, 14, what);
    39954063
    3996         if(utf8)
     4064        if (utf8)
    39974065                yahoo_packet_hash(pkt, 97, "1");
    39984066
     
    40124080        struct yahoo_data *yd;
    40134081        struct yahoo_packet *pkt = NULL;
    4014         if(!yid)
     4082        if (!yid)
    40154083                return;
    40164084
     
    40374105        char s[4];
    40384106
    4039         if(!yid)
     4107        if (!yid)
    40404108                return;
    40414109
     
    40624130        yahoo_packet_free(pkt);
    40634131
    4064         if(old_status == YAHOO_STATUS_INVISIBLE) {
     4132        if (old_status == YAHOO_STATUS_INVISIBLE) {
    40654133                pkt = yahoo_packet_new(YAHOO_SERVICE_Y6_VISIBILITY, YAHOO_STATUS_AVAILABLE, 0);
    40664134                yahoo_packet_hash(pkt, 13, "1");
     
    40764144        struct yahoo_packet *pkt = NULL;
    40774145
    4078         if(!yid)
     4146        if (!yid)
    40794147                return;
    40804148        yd = yid->yd;
     
    40824150        LOG(("yahoo_logoff: current status: %d", yd->current_status));
    40834151
    4084         if(yd->current_status != -1 && 0) {
     4152        if (yd->current_status != -1 && 0) {
    40854153                /* Meh. Don't send this. The event handlers are not going to
    40864154                   get to do this so it'll just leak memory. And the TCP
     
    40974165        do {
    40984166                yahoo_input_close(yid);
    4099         } while((yid = find_input_by_id(id)));
     4167        } while ((yid = find_input_by_id(id)));
    41004168}
    41014169
     
    41064174        struct yahoo_packet *pkt = NULL;
    41074175
    4108         if(!yid)
     4176        if (!yid)
    41094177                return;
    41104178        yd = yid->yd;
     
    41214189{
    41224190        struct yahoo_input_data *yid = data;
    4123         if(fd <= 0) {
     4191        if (fd <= 0) {
    41244192                inputs = y_list_remove(inputs, yid);
    41254193                FREE(yid);
     
    41284196
    41294197        yid->fd = fd;
    4130         yid->read_tag=YAHOO_CALLBACK(ext_yahoo_add_handler)(yid->yd->client_id, fd, YAHOO_INPUT_READ, yid);
     4198        yid->read_tag = YAHOO_CALLBACK(ext_yahoo_add_handler) (yid->yd->client_id, fd, YAHOO_INPUT_READ, yid);
    41314199}
    41324200
     
    41384206        char buff[1024];
    41394207
    4140         if(!yd)
     4208        if (!yd)
    41414209                return;
    41424210
     
    41564224}
    41574225
    4158 void yahoo_set_yab(int id, struct yab * yab)
     4226void yahoo_set_yab(int id, struct yab *yab)
    41594227{
    41604228        struct yahoo_data *yd = find_conn_by_id(id);
     
    41654233        int size = sizeof(url)-1;
    41664234
    4167         if(!yd)
     4235        if (!yd)
    41684236                return;
    41694237
     
    41744242        strncpy(url, "http://insider.msg.yahoo.com/ycontent/?addab2=0", size);
    41754243
    4176         if(yab->dbid) {
     4244        if (yab->dbid) {
    41774245                /* change existing yab */
    41784246                char tmp[32];
     
    41824250        }
    41834251
    4184         if(yab->fname) {
     4252        if (yab->fname) {
    41854253                strncat(url, "&fn=", size - strlen(url));
    41864254                temp = yahoo_urlencode(yab->fname);
     
    41884256                free(temp);
    41894257        }
    4190         if(yab->lname) {
     4258        if (yab->lname) {
    41914259                strncat(url, "&ln=", size - strlen(url));
    41924260                temp = yahoo_urlencode(yab->lname);
     
    41984266        strncat(url, temp, size - strlen(url));
    41994267        free(temp);
    4200         if(yab->nname) {
     4268        if (yab->nname) {
    42014269                strncat(url, "&nn=", size - strlen(url));
    42024270                temp = yahoo_urlencode(yab->nname);
     
    42044272                free(temp);
    42054273        }
    4206         if(yab->email) {
     4274        if (yab->email) {
    42074275                strncat(url, "&e=", size - strlen(url));
    42084276                temp = yahoo_urlencode(yab->email);
     
    42104278                free(temp);
    42114279        }
    4212         if(yab->hphone) {
     4280        if (yab->hphone) {
    42134281                strncat(url, "&hp=", size - strlen(url));
    42144282                temp = yahoo_urlencode(yab->hphone);
     
    42164284                free(temp);
    42174285        }
    4218         if(yab->wphone) {
     4286        if (yab->wphone) {
    42194287                strncat(url, "&wp=", size - strlen(url));
    42204288                temp = yahoo_urlencode(yab->wphone);
     
    42224290                free(temp);
    42234291        }
    4224         if(yab->mphone) {
     4292        if (yab->mphone) {
    42254293                strncat(url, "&mp=", size - strlen(url));
    42264294                temp = yahoo_urlencode(yab->mphone);
     
    42394307}
    42404308
    4241 void yahoo_set_identity_status(int id, const char * identity, int active)
     4309void yahoo_set_identity_status(int id, const char *identity, int active)
    42424310{
    42434311        struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
     
    42454313        struct yahoo_packet *pkt = NULL;
    42464314
    4247         if(!yid)
     4315        if (!yid)
    42484316                return;
    42494317        yd = yid->yd;
     
    42644332        struct yahoo_packet *pkt = NULL;
    42654333
    4266         if(!yid)
     4334        if (!yid)
    42674335                return;
    42684336        yd = yid->yd;
     
    42794347        struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
    42804348        struct yahoo_data *yd;
    4281         struct yahoo_packet *pkt=NULL;
    4282         if(!yid)
     4349        struct yahoo_packet *pkt = NULL;
     4350        if (!yid)
    42834351                return;
    42844352        yd = yid->yd;
     
    43114379        struct yahoo_packet *pkt;
    43124380
    4313         if(!yid)
     4381        if (!yid)
    43144382                return;
    43154383        yd = yid->yd;
     
    43464414        struct yahoo_packet *pkt = NULL;
    43474415
    4348         if(!yid)
     4416        if (!yid)
    43494417                return;
    43504418        yd = yid->yd;
     
    43634431        struct yahoo_data *yd;
    43644432
    4365         if(!yid)
     4433        if (!yid)
    43664434                return;
    43674435        yd = yid->yd;
    43684436
    4369         struct yahoo_packet* pkt=NULL;
     4437        struct yahoo_packet* pkt = NULL;
    43704438        pkt= yahoo_packet_new(YAHOO_SERVICE_CONTACT_YMSG13,YAHOO_STATUS_AVAILABLE,0);
    43714439
     
    43824450        struct yahoo_data *yd;
    43834451
    4384         if(!yid)
     4452        if (!yid)
    43854453                return;
    43864454        yd = yid->yd;
    43874455
    4388         struct yahoo_packet* pkt=NULL;
     4456        struct yahoo_packet* pkt = NULL;
    43894457        pkt= yahoo_packet_new(YAHOO_SERVICE_CONTACT_YMSG13,YAHOO_STATUS_AVAILABLE,0);
    43904458
     
    44084476        struct yahoo_packet *pkt;
    44094477
    4410         if(!yid)
     4478        if (!yid)
    44114479                return;
    44124480        yd = yid->yd;
     
    44294497        struct yahoo_packet *pkt;
    44304498
    4431         if(!yid)
     4499        if (!yid)
    44324500                return;
    44334501        yd = yid->yd;
     
    44504518        struct yahoo_packet *pkt;
    44514519
    4452         if(!yid)
     4520        if (!yid)
    44534521                return;
    44544522        yd = yid->yd;
     
    44724540        struct yahoo_packet *pkt = NULL;
    44734541
    4474         if(!yid)
     4542        if (!yid)
    44754543                return;
    44764544        yd = yid->yd;
     
    44994567        struct yahoo_packet *pkt = NULL;
    45004568
    4501         if(!yid)
     4569        if (!yid)
    45024570                return;
    45034571        yd = yid->yd;
     
    45124580}
    45134581
    4514 void yahoo_conference_addinvite(int id, const char * from, const char *who, const char *room, const YList * members, const char *msg)
     4582void yahoo_conference_addinvite(int id, const char *from, const char *who, const char *room, const YList *members, const char *msg)
    45154583{
    45164584        struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
     
    45184586        struct yahoo_packet *pkt;
    45194587               
    4520         if(!yid)
     4588        if (!yid)
    45214589                return;
    45224590        yd = yid->yd;
     
    45294597        yahoo_packet_hash(pkt, 58, msg);
    45304598        yahoo_packet_hash(pkt, 13, "0");
    4531         for(; members; members = members->next) {
     4599        for (; members; members = members->next) {
    45324600                yahoo_packet_hash(pkt, 52, (char *)members->data);
    45334601                yahoo_packet_hash(pkt, 53, (char *)members->data);
     
    45404608}
    45414609
    4542 void yahoo_conference_invite(int id, const char * from, YList *who, const char *room, const char *msg)
     4610void yahoo_conference_invite(int id, const char *from, YList *who, const char *room, const char *msg)
    45434611{
    45444612        struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
     
    45464614        struct yahoo_packet *pkt;
    45474615               
    4548         if(!yid)
     4616        if (!yid)
    45494617                return;
    45504618        yd = yid->yd;
     
    45544622        yahoo_packet_hash(pkt, 1, (from?from:yd->user));
    45554623        yahoo_packet_hash(pkt, 50, yd->user);
    4556         for(; who; who = who->next) {
     4624        for (; who; who = who->next) {
    45574625                yahoo_packet_hash(pkt, 52, (char *)who->data);
    45584626        }
     
    45724640        struct yahoo_packet *pkt;
    45734641               
    4574         if(!yid)
     4642        if (!yid)
    45754643                return;
    45764644        yd = yid->yd;
     
    45794647
    45804648        yahoo_packet_hash(pkt, 1, (from?from:yd->user));
    4581         for(; who; who = who->next) {
     4649        for (; who; who = who->next) {
    45824650                yahoo_packet_hash(pkt, 3, (char *)who->data);
    45834651        }
     
    45894657}
    45904658
    4591 void yahoo_conference_decline(int id, const char * from, YList *who, const char *room, const char *msg)
     4659void yahoo_conference_decline(int id, const char *from, YList *who, const char *room, const char *msg)
    45924660{
    45934661        struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
     
    45954663        struct yahoo_packet *pkt;
    45964664               
    4597         if(!yid)
     4665        if (!yid)
    45984666                return;
    45994667        yd = yid->yd;
     
    46024670
    46034671        yahoo_packet_hash(pkt, 1, (from?from:yd->user));
    4604         for(; who; who = who->next) {
     4672        for (; who; who = who->next) {
    46054673                yahoo_packet_hash(pkt, 3, (char *)who->data);
    46064674        }
     
    46134681}
    46144682
    4615 void yahoo_conference_logoff(int id, const char * from, YList *who, const char *room)
     4683void yahoo_conference_logoff(int id, const char *from, YList *who, const char *room)
    46164684{
    46174685        struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
     
    46194687        struct yahoo_packet *pkt;
    46204688               
    4621         if(!yid)
     4689        if (!yid)
    46224690                return;
    46234691        yd = yid->yd;
     
    46264694
    46274695        yahoo_packet_hash(pkt, 1, (from?from:yd->user));
    4628         for(; who; who = who->next) {
     4696        for (; who; who = who->next) {
    46294697                yahoo_packet_hash(pkt, 3, (char *)who->data);
    46304698        }
     
    46364704}
    46374705
    4638 void yahoo_conference_message(int id, const char * from, YList *who, const char *room, const char *msg, int utf8)
     4706void yahoo_conference_message(int id, const char *from, YList *who, const char *room, const char *msg, int utf8)
    46394707{
    46404708        struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
     
    46424710        struct yahoo_packet *pkt;
    46434711               
    4644         if(!yid)
     4712        if (!yid)
    46454713                return;
    46464714        yd = yid->yd;
     
    46494717
    46504718        yahoo_packet_hash(pkt, 1, (from?from:yd->user));
    4651         for(; who; who = who->next) {
     4719        for (; who; who = who->next) {
    46524720                yahoo_packet_hash(pkt, 53, (char *)who->data);
    46534721        }
     
    46554723        yahoo_packet_hash(pkt, 14, msg);
    46564724
    4657         if(utf8)
     4725        if (utf8)
    46584726                yahoo_packet_hash(pkt, 97, "1");
    46594727
     
    46704738        char buff[1024];
    46714739
    4672         if(!yd)
     4740        if (!yd)
    46734741                return;
    46744742
     
    46964764        struct yahoo_packet *pkt;
    46974765               
    4698         if(!yid)
     4766        if (!yid)
    46994767                return;
    47004768
     
    47314799        char buf[2];
    47324800               
    4733         if(!yid)
     4801        if (!yid)
    47344802                return;
    47354803
     
    47454813        yahoo_packet_hash(pkt, 124, buf);
    47464814
    4747         if(utf8)
     4815        if (utf8)
    47484816                yahoo_packet_hash(pkt, 97, "1");
    47494817
     
    47604828        struct yahoo_packet *pkt;
    47614829               
    4762         if(!yid)
     4830        if (!yid)
    47634831                return;
    47644832
     
    47804848        struct yahoo_packet *pkt;
    47814849
    4782         if( !yid )
     4850        if ( !yid )
    47834851                return;
    47844852
     
    48014869        char checksum_str[10];
    48024870
    4803         if( !yid )
     4871        if ( !yid )
    48044872                return;
    48054873
     
    48274895        char type_str[10];
    48284896
    4829         if( !yid )
     4897        if ( !yid )
    48304898                return;
    48314899
     
    48504918        char checksum_str[10];
    48514919
    4852         if( !yid )
     4920        if ( !yid )
    48534921                return;
    48544922
     
    48594927        pkt = yahoo_packet_new(YAHOO_SERVICE_PICTURE_CHECKSUM, YAHOO_STATUS_AVAILABLE, 0);
    48604928        yahoo_packet_hash(pkt, 1, yd->user);
    4861         if( who != 0 )
     4929        if ( who != 0 )
    48624930                yahoo_packet_hash(pkt, 5, who);
    48634931        yahoo_packet_hash(pkt, 192, checksum_str);
     
    48724940        struct yahoo_input_data *yid = find_input_by_id_and_webcam_user(id, who);
    48734941
    4874         if(yid)
     4942        if (yid)
    48754943                yahoo_input_close(yid);
    48764944}
     
    48824950        struct yahoo_packet *pkt;
    48834951               
    4884         if(!yid)
     4952        if (!yid)
    48854953                return;
    48864954
     
    49685036        struct yahoo_packet *pkt;
    49695037               
    4970         if(!yid)
     5038        if (!yid)
    49715039                return;
    49725040
     
    49915059        char *ctext, *p;
    49925060
    4993         if(!yd)
     5061        if (!yd)
    49945062                return;
    49955063
     
    50065074
    50075075        ctext = strdup(text);
    5008         while((p = strchr(ctext, ' ')))
     5076        while ((p = strchr(ctext, ' ')))
    50095077                *p = '+';
    50105078
     
    50275095        struct yahoo_search_state *yss;
    50285096
    5029         if(!yid)
    5030                 return;
    5031 
    5032         if(!yid->ys)
     5097        if (!yid)
     5098                return;
     5099
     5100        if (!yid->ys)
    50335101                yid->ys = y_new0(struct yahoo_search_state, 1);
    50345102
     
    50515119        struct yahoo_search_state *yss;
    50525120
    5053         if(!yid || !yid->ys)
     5121        if (!yid || !yid->ys)
    50545122                return;
    50555123
    50565124        yss = yid->ys;
    50575125
    5058         if(start == -1)
     5126        if (start == -1)
    50595127                start = yss->lsearch_nstart + yss->lsearch_nfound;
    50605128
     
    50785146        unsigned char buff[1024];
    50795147
    5080         if(fd <= 0) {
     5148        if (fd <= 0) {
    50815149                sfd->callback(id, fd, error, sfd->user_data);
    50825150                FREE(sfd);
     
    50975165        write(yid->fd, buff, 4);
    50985166
    5099         /*      YAHOO_CALLBACK(ext_yahoo_add_handler)(nyd->fd, YAHOO_INPUT_READ); */
     5167        /*      YAHOO_CALLBACK(ext_yahoo_add_handler) (nyd->fd, YAHOO_INPUT_READ); */
    51005168
    51015169        sfd->callback(id, fd, error, sfd->user_data);
     
    51035171        inputs = y_list_remove(inputs, yid);
    51045172        /*
    5105         while(yahoo_tcp_readline(buff, sizeof(buff), nyd->fd) > 0) {
    5106         if(!strcmp(buff, ""))
     5173        while (yahoo_tcp_readline(buff, sizeof(buff), nyd->fd) > 0) {
     5174        if (!strcmp(buff, ""))
    51075175        break;
    51085176}
     
    51215189        char size_str[10];
    51225190        char expire_str[10];
    5123         long content_length=0;
     5191        long content_length = 0;
    51245192        unsigned char buff[1024];
    51255193        char url[255];
    51265194        struct send_file_data *sfd;
    51275195
    5128         if(!yd)
     5196        if (!yd)
    51295197                return;
    51305198
     
    51715239        unsigned char buff[1024];
    51725240
    5173         if(fd <= 0) {
     5241        if (fd <= 0) {
    51745242                sfd->callback(id, fd, error, sfd->user_data);
    51755243                FREE(sfd);
     
    51905258        write(yid->fd, buff, 4);
    51915259
    5192 /*      YAHOO_CALLBACK(ext_yahoo_add_handler)(nyd->fd, YAHOO_INPUT_READ); */
     5260/*      YAHOO_CALLBACK(ext_yahoo_add_handler) (nyd->fd, YAHOO_INPUT_READ); */
    51935261
    51945262        sfd->callback(id, fd, error, sfd->user_data);
     
    51965264        inputs = y_list_remove(inputs, yid);
    51975265        /*
    5198         while(yahoo_tcp_readline(buff, sizeof(buff), nyd->fd) > 0) {
    5199                 if(!strcmp(buff, ""))
     5266        while (yahoo_tcp_readline(buff, sizeof(buff), nyd->fd) > 0) {
     5267                if (!strcmp(buff, ""))
    52005268                        break;
    52015269        }
     
    52145282        struct yahoo_packet *pkt = NULL;
    52155283        char size_str[10];
    5216         long content_length=0;
     5284        long content_length = 0;
    52175285        unsigned char buff[1024];
    52185286        char url[255];
    52195287        struct send_file_data *sfd;
    52205288
    5221         if(!yd)
     5289        if (!yd)
    52225290                return;
    52235291
     
    52585326{
    52595327        struct yahoo_data *yd = find_conn_by_id(id);
    5260         if(!yd)
     5328        if (!yd)
    52615329                return YAHOO_STATUS_OFFLINE;
    52625330        return yd->current_status;
    52635331}
    52645332
    5265 const YList * yahoo_get_buddylist(int id)
     5333const YList *yahoo_get_buddylist(int id)
    52665334{
    52675335        struct yahoo_data *yd = find_conn_by_id(id);
    5268         if(!yd)
     5336        if (!yd)
    52695337                return NULL;
    52705338        return yd->buddies;
    52715339}
    52725340
    5273 const YList * yahoo_get_ignorelist(int id)
     5341const YList *yahoo_get_ignorelist(int id)
    52745342{
    52755343        struct yahoo_data *yd = find_conn_by_id(id);
    5276         if(!yd)
     5344        if (!yd)
    52775345                return NULL;
    52785346        return yd->ignore;
    52795347}
    52805348
    5281 const YList * yahoo_get_identities(int id)
     5349const YList *yahoo_get_identities(int id)
    52825350{
    52835351        struct yahoo_data *yd = find_conn_by_id(id);
    5284         if(!yd)
     5352        if (!yd)
    52855353                return NULL;
    52865354        return yd->identities;
    52875355}
    52885356
    5289 const char * yahoo_get_cookie(int id, const char *which)
     5357const char *yahoo_get_cookie(int id, const char *which)
    52905358{
    52915359        struct yahoo_data *yd = find_conn_by_id(id);
    5292         if(!yd)
     5360        if (!yd)
    52935361                return NULL;
    5294         if(!strncasecmp(which, "y", 1))
     5362        if (!strncasecmp(which, "y", 1))
    52955363                return yd->cookie_y;
    5296         if(!strncasecmp(which, "t", 1))
     5364        if (!strncasecmp(which, "t", 1))
    52975365                return yd->cookie_t;
    5298         if(!strncasecmp(which, "c", 1))
     5366        if (!strncasecmp(which, "c", 1))
    52995367                return yd->cookie_c;
    5300         if(!strncasecmp(which, "login", 5))
     5368        if (!strncasecmp(which, "login", 5))
    53015369                return yd->login_cookie;
    53025370        return NULL;
     
    53075375{
    53085376        struct yahoo_data *yd = find_conn_by_id(id);
    5309         if(!yd)
     5377        if (!yd)
    53105378                return;
    53115379
     
    53135381}
    53145382
    5315 const char * yahoo_get_profile_url( void )
     5383const char *yahoo_get_profile_url( void )
    53165384{
    53175385        return profile_url;
  • protocols/yahoo/yahoo2.h

    r938c305 rc36f73b  
    6262/* who always means the buddy you're acting on */
    6363/* id is the successful value returned by yahoo_init */
    64 
    6564
    6665/* init returns a connection id used to identify the connection hereon */
     
    8887 * You should set at least local_host if you intend to use webcams
    8988 */
    90 int  yahoo_init_with_attributes(const char *username, const char *password, ...);
     89        int yahoo_init_with_attributes(const char *username,
     90                const char *password, ...);
    9191
    9292/* yahoo_init does the same as yahoo_init_with_attributes, assuming defaults
    9393 * for all attributes */
    94 int  yahoo_init(const char *username, const char *password);
    95 
    96 
     94        int yahoo_init(const char *username, const char *password);
    9795
    9896/* release all resources held by this session */
    9997/* you need to call yahoo_close for a session only if
    10098 * yahoo_logoff is never called for it (ie, it was never logged in) */
    101 void yahoo_close(int id);
     99        void yahoo_close(int id);
    102100/* login logs in to the server */
    103101/* initial is of type enum yahoo_status.  see yahoo2_types.h */
    104 void yahoo_login(int id, int initial);
    105 void yahoo_logoff(int id);
     102        void yahoo_login(int id, int initial);
     103        void yahoo_logoff(int id);
    106104/* reloads status of all buddies */
    107 void yahoo_refresh(int id);
     105        void yahoo_refresh(int id);
    108106/* activates/deactivates an identity */
    109 void yahoo_set_identity_status(int id, const char * identity, int active);
     107        void yahoo_set_identity_status(int id, const char *identity,
     108                int active);
    110109/* regets the entire buddy list from the server */
    111 void yahoo_get_list(int id);
     110        void yahoo_get_list(int id);
    112111/* download buddy contact information from your yahoo addressbook */
    113 void yahoo_get_yab(int id);
     112        void yahoo_get_yab(int id);
    114113/* add/modify an address book entry.  if yab->dbid is set, it will */
    115114/* modify that entry else it creates a new entry */
    116 void yahoo_set_yab(int id, struct yab * yab);
    117 void yahoo_keepalive(int id);
    118 void yahoo_chat_keepalive(int id);
     115        void yahoo_set_yab(int id, struct yab *yab);
     116        void yahoo_keepalive(int id);
     117        void yahoo_chat_keepalive(int id);
    119118
    120119/* from is the identity you're sending from.  if NULL, the default is used */
    121120/* utf8 is whether msg is a utf8 string or not. */
    122 void yahoo_send_im(int id, const char *from, const char *who, const char *msg, int utf8, int picture);
     121        void yahoo_send_im(int id, const char *from, const char *who,
     122                const char *msg, int utf8, int picture);
     123        void yahoo_send_buzz(int id, const char *from, const char *who);
    123124/* if type is true, send typing notice, else send stopped typing notice */
    124 void yahoo_send_typing(int id, const char *from, const char *who, int typ);
     125        void yahoo_send_typing(int id, const char *from, const char *who,
     126                int typ);
    125127
    126128/* used to set away/back status. */
    127129/* away says whether the custom message is an away message or a sig */
    128 void yahoo_set_away(int id, enum yahoo_status state, const char *msg, int away);
    129 
    130 void yahoo_add_buddy(int id, const char *who, const char *group, const char *msg);
    131 void yahoo_remove_buddy(int id, const char *who, const char *group);
    132 void yahoo_reject_buddy(int id, const char *who, const char *msg);
    133 void yahoo_stealth_buddy(int id, const char *who, int unstealth);
     130        void yahoo_set_away(int id, enum yahoo_status state, const char *msg,
     131                int away);
     132
     133        void yahoo_add_buddy(int id, const char *who, const char *group,
     134                const char *msg);
     135        void yahoo_remove_buddy(int id, const char *who, const char *group);
     136        void yahoo_confirm_buddy(int id, const char *who, int reject,
     137                const char *msg);
     138        void yahoo_stealth_buddy(int id, const char *who, int unstealth);
    134139/* if unignore is true, unignore, else ignore */
    135 void yahoo_ignore_buddy(int id, const char *who, int unignore);
    136 void yahoo_change_buddy_group(int id, const char *who, const char *old_group, const char *new_group);
    137 void yahoo_group_rename(int id, const char *old_group, const char *new_group);
    138 
    139 void yahoo_conference_invite(int id, const char * from, YList *who, const char *room, const char *msg);
    140 void yahoo_conference_addinvite(int id, const char * from, const char *who, const char *room, const YList * members, const char *msg);
    141 void yahoo_conference_decline(int id, const char * from, YList *who, const char *room, const char *msg);
    142 void yahoo_conference_message(int id, const char * from, YList *who, const char *room, const char *msg, int utf8);
    143 void yahoo_conference_logon(int id, const char * from, YList *who, const char *room);
    144 void yahoo_conference_logoff(int id, const char * from, YList *who, const char *room);
     140        void yahoo_ignore_buddy(int id, const char *who, int unignore);
     141        void yahoo_change_buddy_group(int id, const char *who,
     142                const char *old_group, const char *new_group);
     143        void yahoo_group_rename(int id, const char *old_group,
     144                const char *new_group);
     145
     146        void yahoo_conference_invite(int id, const char *from, YList *who,
     147                const char *room, const char *msg);
     148        void yahoo_conference_addinvite(int id, const char *from,
     149                const char *who, const char *room, const YList *members,
     150                const char *msg);
     151        void yahoo_conference_decline(int id, const char *from, YList *who,
     152                const char *room, const char *msg);
     153        void yahoo_conference_message(int id, const char *from, YList *who,
     154                const char *room, const char *msg, int utf8);
     155        void yahoo_conference_logon(int id, const char *from, YList *who,
     156                const char *room);
     157        void yahoo_conference_logoff(int id, const char *from, YList *who,
     158                const char *room);
    145159
    146160/* Get a list of chatrooms */
    147 void yahoo_get_chatrooms(int id,int chatroomid);
     161        void yahoo_get_chatrooms(int id, int chatroomid);
    148162/* join room with specified roomname and roomid */
    149 void yahoo_chat_logon(int id, const char *from, const char *room, const char *roomid);
     163        void yahoo_chat_logon(int id, const char *from, const char *room,
     164                const char *roomid);
    150165/* Send message "msg" to room with specified roomname, msgtype is 1-normal message or 2-/me mesage */
    151 void yahoo_chat_message(int id, const char *from, const char *room, const char *msg, const int msgtype, const int utf8);
     166        void yahoo_chat_message(int id, const char *from, const char *room,
     167                const char *msg, const int msgtype, const int utf8);
    152168/* Log off chat */
    153 void yahoo_chat_logoff(int id, const char *from);
     169        void yahoo_chat_logoff(int id, const char *from);
    154170
    155171/* requests a webcam feed */
    156172/* who is the person who's webcam you would like to view */
    157173/* if who is null, then you're the broadcaster */
    158 void yahoo_webcam_get_feed(int id, const char *who);
    159 void yahoo_webcam_close_feed(int id, const char *who);
     174        void yahoo_webcam_get_feed(int id, const char *who);
     175        void yahoo_webcam_close_feed(int id, const char *who);
    160176
    161177/* sends an image when uploading */
     
    163179/* in bytes. The timestamp is the time in milliseconds since we started the */
    164180/* webcam. */
    165 void yahoo_webcam_send_image(int id, unsigned char *image, unsigned int length, unsigned int timestamp);
     181        void yahoo_webcam_send_image(int id, unsigned char *image,
     182                unsigned int length, unsigned int timestamp);
    166183
    167184/* this function should be called if we want to allow a user to watch the */
    168185/* webcam. Who is the user we want to accept. */
    169186/* Accept user (accept = 1), decline user (accept = 0) */
    170 void yahoo_webcam_accept_viewer(int id, const char* who, int accept);
     187        void yahoo_webcam_accept_viewer(int id, const char *who, int accept);
    171188
    172189/* send an invitation to a user to view your webcam */
    173 void yahoo_webcam_invite(int id, const char *who);
     190        void yahoo_webcam_invite(int id, const char *who);
    174191
    175192/* will set up a connection and initiate file transfer.
     
    177194 * the file data to
    178195 */
    179 void yahoo_send_file(int id, const char *who, const char *msg, const char *name, unsigned long size,
     196        void yahoo_send_file(int id, const char *who, const char *msg,
     197                const char *name, unsigned long size,
    180198                yahoo_get_fd_callback callback, void *data);
    181199
     200/*
     201 * Respond to a file transfer request. Be sure to provide the callback data
     202 * since that is your only chance to recognize future callbacks
     203 */
     204        void yahoo_send_file_transfer_response(int client_id, int response,
     205                char *id, void *data);
     206
     207
    182208/* send a search request
    183209 */
    184 void yahoo_search(int id, enum yahoo_search_type t, const char *text, enum yahoo_search_gender g, enum yahoo_search_agerange ar,
     210        void yahoo_search(int id, enum yahoo_search_type t, const char *text,
     211                enum yahoo_search_gender g, enum yahoo_search_agerange ar,
    185212                int photo, int yahoo_only);
    186213
     
    190217 * where the above three are passed to ext_yahoo_got_search_result
    191218 */
    192 void yahoo_search_again(int id, int start);
    193 
    194 /* returns a socket fd to a url for downloading a file. */
    195 void yahoo_get_url_handle(int id, const char *url,
    196                 yahoo_get_url_handle_callback callback, void *data);
     219        void yahoo_search_again(int id, int start);
    197220
    198221/* these should be called when input is available on a fd */
     
    203226
    204227/* utility functions. these do not hit the server */
    205 enum yahoo_status yahoo_current_status(int id);
    206 const YList * yahoo_get_buddylist(int id);
    207 const YList * yahoo_get_ignorelist(int id);
    208 const YList * yahoo_get_identities(int id);
     228        enum yahoo_status yahoo_current_status(int id);
     229        const YList *yahoo_get_buddylist(int id);
     230        const YList *yahoo_get_ignorelist(int id);
     231        const YList *yahoo_get_identities(int id);
    209232/* 'which' could be y, t, c or login.  This may change in later versions. */
    210 const char  * yahoo_get_cookie(int id, const char *which);
     233        const char *yahoo_get_cookie(int id, const char *which);
    211234
    212235/* returns the url used to get user profiles - you must append the user id */
    213236/* as of now this is http://profiles.yahoo.com/ */
    214237/* You'll have to do urlencoding yourself, but see yahoo_httplib.h first */
    215 const char  * yahoo_get_profile_url( void );
    216 
    217 void yahoo_buddyicon_request(int id, const char *who);
    218 
    219 void yahoo_accept_buddy_ymsg13(int,const char*,const char*);
    220 void yahoo_reject_buddy_ymsg13(int,const char*,const char*,const char*);
     238        const char *yahoo_get_profile_url(void);
     239
     240        void yahoo_buddyicon_request(int id, const char *who);
     241
     242        void yahoo_accept_buddy_ymsg13(int,const char*, const char*);
     243        void yahoo_reject_buddy_ymsg13(int,const char*, const char*, const char*);
    221244
    222245#include "yahoo_httplib.h"
     
    225248}
    226249#endif
    227 
    228250#endif
  • protocols/yahoo/yahoo2_callbacks.h

    r938c305 rc36f73b  
    3030 */
    3131
    32 
    3332#ifndef YAHOO2_CALLBACKS_H
    3433#define YAHOO2_CALLBACKS_H
     
    4645 */
    4746
    48 typedef enum {
    49         YAHOO_INPUT_READ = 1 << 0,
    50         YAHOO_INPUT_WRITE = 1 << 1,
    51         YAHOO_INPUT_EXCEPTION = 1 << 2
    52 } yahoo_input_condition;
     47        typedef enum {
     48                YAHOO_INPUT_READ = 1 << 0,
     49                YAHOO_INPUT_WRITE = 1 << 1,
     50                YAHOO_INPUT_EXCEPTION = 1 << 2
     51        } yahoo_input_condition;
    5352
    5453/*
     
    9493 *      url  - url to reactivate account if locked
    9594 */
    96 void YAHOO_CALLBACK_TYPE(ext_yahoo_login_response)(int id, int succ, const char *url);
    97 
     95        void YAHOO_CALLBACK_TYPE(ext_yahoo_login_response) (int id, int succ,
     96                const char *url);
    9897
    9998/*
     
    104103 *      buds - the buddy list
    105104 */
    106 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_buddies)(int id, YList * buds);
    107 
     105        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_buddies) (int id, YList *buds);
    108106
    109107/*
     
    114112 *      igns - the ignore list
    115113 */
    116 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_ignore)(int id, YList * igns);
    117 
     114        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_ignore) (int id, YList *igns);
    118115
    119116/*
     
    124121 *      ids  - the identity list
    125122 */
    126 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_identities)(int id, YList * ids);
    127 
     123        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_identities) (int id, YList *ids);
    128124
    129125/*
     
    133129 *      id   - the id that identifies the server connection
    134130 */
    135 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_cookies)(int id);
    136 
     131        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_cookies) (int id);
    137132
    138133/*
     
    143138 *  errormsg - optional error message
    144139 */
    145 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_ping)(int id, const char *errormsg);
    146 
     140        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_ping) (int id,
     141                const char *errormsg);
    147142
    148143/*
     
    159154 *      TODO: add support for pager, chat, and game states
    160155 */
    161 void YAHOO_CALLBACK_TYPE(ext_yahoo_status_changed)(int id, const char *who, int stat, const char *msg, int away, int idle, int mobile);
    162 
     156        void YAHOO_CALLBACK_TYPE(ext_yahoo_status_changed) (int id,
     157                const char *who, int stat, const char *msg, int away, int idle,
     158                int mobile);
     159
     160/*
     161 * Name: ext_yahoo_got_buzz
     162 *      Called when remote user sends you a buzz.
     163 * Params:
     164 *      id   - the id that identifies the server connection
     165 *      me   - the identity the message was sent to
     166 *      who  - the handle of the remote user
     167 *      tm   - timestamp of message if offline
     168 */
     169        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_buzz) (int id, const char *me,
     170                const char *who, long tm);
    163171
    164172/*
     
    177185 *      utf8 - whether the message is encoded as utf8 or not
    178186 */
    179 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_im)(int id, const char *me, const char *who, const char *msg, long tm, int stat, int utf8);
    180 
     187        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_im) (int id, const char *me,
     188                const char *who, const char *msg, long tm, int stat, int utf8);
    181189
    182190/*
     
    191199 *      members - the initial members of the conference (null terminated list)
    192200 */
    193 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_conf_invite)(int id, const char *me, const char *who, const char *room, const char *msg, YList *members);
    194 
     201        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_conf_invite) (int id,
     202                const char *me, const char *who, const char *room,
     203                const char *msg, YList *members);
    195204
    196205/*
     
    204213 *      msg  - the declining message
    205214 */
    206 void YAHOO_CALLBACK_TYPE(ext_yahoo_conf_userdecline)(int id, const char *me, const char *who, const char *room, const char *msg);
    207 
     215        void YAHOO_CALLBACK_TYPE(ext_yahoo_conf_userdecline) (int id,
     216                const char *me, const char *who, const char *room,
     217                const char *msg);
    208218
    209219/*
     
    216226 *      room - the room joined
    217227 */
    218 void YAHOO_CALLBACK_TYPE(ext_yahoo_conf_userjoin)(int id, const char *me, const char *who, const char *room);
    219 
     228        void YAHOO_CALLBACK_TYPE(ext_yahoo_conf_userjoin) (int id,
     229                const char *me, const char *who, const char *room);
    220230
    221231/*
     
    228238 *      room - the room left
    229239 */
    230 void YAHOO_CALLBACK_TYPE(ext_yahoo_conf_userleave)(int id, const char *me, const char *who, const char *room);
    231 
     240        void YAHOO_CALLBACK_TYPE(ext_yahoo_conf_userleave) (int id,
     241                const char *me, const char *who, const char *room);
    232242
    233243/*
     
    238248 *      xml     - ?
    239249 */
    240 void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_cat_xml)(int id, const char *xml);
    241 
     250        void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_cat_xml) (int id,
     251                const char *xml);
    242252
    243253/*
     
    254264 *      fd      - the socket where the connection is coming from (for tracking)
    255265 */
    256 void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_join)(int id, const char *me, const char *room, const char *topic, YList *members, int fd);
    257 
     266        void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_join) (int id, const char *me,
     267                const char *room, const char *topic, YList *members, int fd);
    258268
    259269/*
     
    266276 *      who  - the user who has joined, Must be freed by the client
    267277 */
    268 void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_userjoin)(int id, const char *me, const char *room, struct yahoo_chat_member *who);
    269 
     278        void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_userjoin) (int id,
     279                const char *me, const char *room,
     280                struct yahoo_chat_member *who);
    270281
    271282/*
     
    278289 *      who  - the user who has left (Just the User ID)
    279290 */
    280 void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_userleave)(int id, const char *me, const char *room, const char *who);
    281 
     291        void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_userleave) (int id,
     292                const char *me, const char *room, const char *who);
    282293
    283294/*
     
    294305 *      utf8 - whether the message is utf8 encoded or not
    295306 */
    296 void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_message)(int id, const char *me, const char *who, const char *room, const char *msg, int msgtype, int utf8);
    297 
     307        void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_message) (int id,
     308                const char *me, const char *who, const char *room,
     309                const char *msg, int msgtype, int utf8);
    298310
    299311/*
     
    310322 *      nothing.
    311323 */
    312 void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_yahoologout)(int id, const char *me);
    313 
     324        void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_yahoologout) (int id,
     325                const char *me);
    314326
    315327/*
     
    327339 *      nothing.
    328340 */
    329 void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_yahooerror)(int id, const char *me);
    330 
     341        void YAHOO_CALLBACK_TYPE(ext_yahoo_chat_yahooerror) (int id,
     342                const char *me);
    331343
    332344/*
     
    341353 *      utf8 - whether the message is utf8 encoded or not
    342354 */
    343 void YAHOO_CALLBACK_TYPE(ext_yahoo_conf_message)(int id, const char *me, const char *who, const char *room, const char *msg, int utf8);
    344 
     355        void YAHOO_CALLBACK_TYPE(ext_yahoo_conf_message) (int id,
     356                const char *me, const char *who, const char *room,
     357                const char *msg, int utf8);
    345358
    346359/*
     
    381394 *      msg  - any message sent
    382395 */
    383 void YAHOO_CALLBACK_TYPE(ext_yahoo_contact_added)(int id, const char *myid, const char *who, const char *msg);
    384 
     396        void YAHOO_CALLBACK_TYPE(ext_yahoo_contact_added) (int id,
     397                const char *myid, const char *who, const char *msg);
    385398
    386399/*
     
    392405 *      msg  - any message sent
    393406 */
    394 void YAHOO_CALLBACK_TYPE(ext_yahoo_rejected)(int id, const char *who, const char *msg);
    395 
     407        void YAHOO_CALLBACK_TYPE(ext_yahoo_rejected) (int id, const char *who,
     408                const char *msg);
    396409
    397410/*
     
    404417 *      stat - 1 if typing, 0 if stopped typing
    405418 */
    406 void YAHOO_CALLBACK_TYPE(ext_yahoo_typing_notify)(int id, const char *me, const char *who, int stat);
    407 
     419        void YAHOO_CALLBACK_TYPE(ext_yahoo_typing_notify) (int id,
     420                const char *me, const char *who, int stat);
    408421
    409422/*
     
    428441 *      cnt  - mail count - 0 if new mail notification
    429442 */
    430 void YAHOO_CALLBACK_TYPE(ext_yahoo_mail_notify)(int id, const char *from, const char *subj, int cnt);
    431 
     443        void YAHOO_CALLBACK_TYPE(ext_yahoo_mail_notify) (int id,
     444                const char *from, const char *subj, int cnt);
    432445
    433446/*
     
    450463 *      checksum - the checksum of the icon content
    451464 */
    452 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_buddyicon)(int id, const char *me, const char *who, const char *url, int checksum);
     465        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_buddyicon) (int id,
     466                const char *me, const char *who, const char *url, int checksum);
    453467
    454468/*
     
    461475 *      checksum - the checksum of the icon content
    462476 */
    463 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_buddyicon_checksum)(int id, const char *me,const char *who, int checksum);
     477        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_buddyicon_checksum) (int id,
     478                const char *me, const char *who, int checksum);
    464479
    465480/*
     
    471486 *      who - the yahoo id of the buddy that requested the buddy icon
    472487 */
    473 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_buddyicon_request)(int id, const char *me, const char *who);
     488        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_buddyicon_request) (int id,
     489                const char *me, const char *who);
    474490
    475491/*
     
    480496 *      url - remote url, the uploaded buddy icon can be fetched from
    481497 */
    482 void YAHOO_CALLBACK_TYPE(ext_yahoo_buddyicon_uploaded)(int id, const char *url);
     498        void YAHOO_CALLBACK_TYPE(ext_yahoo_buddyicon_uploaded) (int id,
     499                const char *url);
    483500
    484501/*
     
    505522 *      a timestamp to stay in sync
    506523 */
    507 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_webcam_image)(int id, const char * who,
    508                 const unsigned char *image, unsigned int image_size, unsigned int real_size,
     524        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_webcam_image) (int id,
     525                const char *who, const unsigned char *image,
     526                unsigned int image_size, unsigned int real_size,
    509527                unsigned int timestamp);
    510 
    511528
    512529/*
     
    518535 *      from - who the invitation is from
    519536 */
    520 void YAHOO_CALLBACK_TYPE(ext_yahoo_webcam_invite)(int id, const char *me, const char *from);
    521 
     537        void YAHOO_CALLBACK_TYPE(ext_yahoo_webcam_invite) (int id,
     538                const char *me, const char *from);
    522539
    523540/*
     
    530547 *      accept - 0 (decline), 1 (accept)
    531548 */
    532 void YAHOO_CALLBACK_TYPE(ext_yahoo_webcam_invite_reply)(int id, const char *me, const char *from, int accept);
    533 
     549        void YAHOO_CALLBACK_TYPE(ext_yahoo_webcam_invite_reply) (int id,
     550                const char *me, const char *from, int accept);
    534551
    535552/*
     
    545562 *               4 = user does not have webcam online
    546563 */
    547 void YAHOO_CALLBACK_TYPE(ext_yahoo_webcam_closed)(int id, const char *who, int reason);
    548 
     564        void YAHOO_CALLBACK_TYPE(ext_yahoo_webcam_closed) (int id,
     565                const char *who, int reason);
    549566
    550567/*
     
    560577 *                 if you need to use the information, make a copy
    561578 */
    562 void YAHOO_CALLBACK_TYPE(ext_yahoo_got_search_result)(int id, int found, int start, int total, YList *contacts);
    563 
     579        void YAHOO_CALLBACK_TYPE(ext_yahoo_got_search_result) (int id,
     580                int found, int start, int total, YList *contacts);
    564581
    565582/*
     
    572589 *      num  - Which error is this
    573590 */
    574 void YAHOO_CALLBACK_TYPE(ext_yahoo_error)(int id, const char *err, int fatal, int num);
    575 
     591        void YAHOO_CALLBACK_TYPE(ext_yahoo_error) (int id, const char *err,
     592                int fatal, int num);
    576593
    577594/*
     
    583600 *      connect - 0=disconnect 1=connect 2=request
    584601 */
    585 void YAHOO_CALLBACK_TYPE(ext_yahoo_webcam_viewer)(int id, const char *who, int connect);
    586 
     602        void YAHOO_CALLBACK_TYPE(ext_yahoo_webcam_viewer) (int id,
     603                const char *who, int connect);
    587604
    588605/*
     
    593610 *      send - whether to send images or not
    594611 */
    595 void YAHOO_CALLBACK_TYPE(ext_yahoo_webcam_data_request)(int id, int send);
    596 
     612        void YAHOO_CALLBACK_TYPE(ext_yahoo_webcam_data_request) (int id,
     613                int send);
    597614
    598615/*
     
    604621 *      0
    605622 */
    606 int YAHOO_CALLBACK_TYPE(ext_yahoo_log)(const char *fmt, ...);
    607 
     623        int YAHOO_CALLBACK_TYPE(ext_yahoo_log) (const char *fmt, ...);
    608624
    609625/*
     
    620636 * Returns: a tag to be used when removing the handler
    621637 */
    622 int YAHOO_CALLBACK_TYPE(ext_yahoo_add_handler)(int id, int fd, yahoo_input_condition cond, void *data);
    623 
     638        int YAHOO_CALLBACK_TYPE(ext_yahoo_add_handler) (int id, int fd,
     639                yahoo_input_condition cond, void *data);
    624640
    625641/*
     
    630646 *      tag  - the handler tag to remove
    631647 */
    632 void YAHOO_CALLBACK_TYPE(ext_yahoo_remove_handler)(int id, int tag);
    633 
     648        void YAHOO_CALLBACK_TYPE(ext_yahoo_remove_handler) (int id, int tag);
    634649
    635650/*
     
    642657 *      a unix file descriptor to the socket
    643658 */
    644 int YAHOO_CALLBACK_TYPE(ext_yahoo_connect)(const char *host, int port);
    645 
     659        int YAHOO_CALLBACK_TYPE(ext_yahoo_connect) (const char *host, int port);
    646660
    647661/*
    648662 * Name: ext_yahoo_connect_async
    649  *      Connect to a host:port asynchronously.  This function should return
     663 *      Connect to a host:port asynchronously. This function should return
    650664 *      immediately returing a tag used to identify the connection handler,
    651665 *      or a pre-connect error (eg: host name lookup failure).
     
    663677 *      a unix file descriptor to the socket
    664678 */
    665 int YAHOO_CALLBACK_TYPE(ext_yahoo_connect_async)(int id, const char *host, int port,
    666                 yahoo_connect_callback callback, void *callback_data);
     679        int YAHOO_CALLBACK_TYPE(ext_yahoo_connect_async) (int id,
     680                const char *host, int port, yahoo_connect_callback callback,
     681                void *callback_data);
    667682
    668683#ifdef USE_STRUCT_CALLBACKS
     
    673688 * before doing anything else
    674689 */
    675 void yahoo_register_callbacks(struct yahoo_callbacks * tyc);
     690void yahoo_register_callbacks(struct yahoo_callbacks *tyc);
    676691
    677692#undef YAHOO_CALLBACK_TYPE
  • protocols/yahoo/yahoo2_types.h

    r938c305 rc36f73b  
    201201
    202202struct yab {
     203        int yid;
    203204        char *id;
    204205        char *fname;
  • protocols/yahoo/yahoo_fn.h

    r938c305 rc36f73b  
    1919 */
    2020
    21 #define IDENT  1 /* identify function */
    22 #define XOR    2 /* xor with arg1 */
    23 #define MULADD 3 /* multipy by arg1 then add arg2 */
    24 #define LOOKUP 4 /* lookup each byte in the table pointed to by arg1 */
    25 #define BITFLD 5 /* reorder bits according to table pointed to by arg1 */
     21#define IDENT  1                /* identify function */
     22#define XOR    2                /* xor with arg1 */
     23#define MULADD 3                /* multipy by arg1 then add arg2 */
     24#define LOOKUP 4                /* lookup each byte in the table pointed to by arg1 */
     25#define BITFLD 5                /* reorder bits according to table pointed to by arg1 */
    2626
    27 struct yahoo_fn
    28 {
    29         int type;
     27struct yahoo_fn {
     28        int type;
    3029        long arg1, arg2;
    3130};
    3231
    33 int yahoo_xfrm( int table, int depth, int seed );
     32int yahoo_xfrm(int table, int depth, int seed);
  • protocols/yahoo/yahoo_util.c

    r938c305 rc36f73b  
    3636#include "yahoo_util.h"
    3737
    38 char * y_string_append(char * string, char * append)
     38char *y_string_append(char *string, char *append)
    3939{
    4040        int size = strlen(string) + strlen(append) + 1;
    41         char * new_string = y_renew(char, string, size);
     41        char *new_string = y_renew(char, string, size);
    4242
    43         if(new_string == NULL) {
     43        if (new_string == NULL) {
    4444                new_string = y_new(char, size);
    4545                strcpy(new_string, string);
  • protocols/yahoo/yahoo_util.h

    r938c305 rc36f73b  
    6161# define y_renew(type, mem, n)  (type *)realloc(mem, n)
    6262
    63 void * y_memdup(const void * addr, int n);
    64 char ** y_strsplit(char * str, char * sep, int nelem);
    65 void y_strfreev(char ** vector);
     63void *y_memdup(const void *addr, int n);
     64char **y_strsplit(char *str, char *sep, int nelem);
     65void y_strfreev(char **vector);
    6666
    67 int strncasecmp(const char * s1, const char * s2, size_t n);
    68 int strcasecmp(const char * s1, const char * s2);
     67#ifndef _WIN32
     68int strncasecmp(const char *s1, const char *s2, size_t n);
     69int strcasecmp(const char *s1, const char *s2);
    6970
    70 char * strdup(const char *s);
     71char *strdup(const char *s);
    7172
    7273int snprintf(char *str, size_t size, const char *format, ...);
    7374int vsnprintf(char *str, size_t size, const char *format, va_list ap);
     75#endif
    7476
    7577#endif
     
    9597 * You must free it yourself
    9698 */
    97 char * y_string_append(char * str, char * append);
    98 char * y_str_to_utf8(const char * in);
    99 char * y_utf8_to_str(const char * in);
     99char *y_string_append(char *str, char *append);
     100char *y_str_to_utf8(const char *in);
     101char *y_utf8_to_str(const char *in);
    100102
    101103#endif
Note: See TracChangeset for help on using the changeset viewer.