1 #include <stdio.h>

     2 #include <stdlib.h>

     3 #include <string.h>

     4 #include <ncurses.h>

     5 #include <panel.h>

     6 #include "screen.h"

     7 #include "buddies.h"

     8 

     9 #include "lang.h"

    10 #include "utils.h"

    11 #include "server.h"

    12 #include "list.h"

    13 #include "harddefines.h"

    14 

    15 /* global vars for BUDDIES.C */

    16 int buddySelected = 1;		/* Hold the selected Buddy  */

    17 int buddyOffset = 0;		/* Hold the roster offset   */

    18 

    19 static LIST_HEAD(buddy_list);

    20 static LIST_HEAD(sorted_buddies);

    21 #define buddy_entry(n) list_entry(n, buddy_entry_t, list)

    22 

    23 

    24 void bud_SetBuddyStatus(char *jidfrom, int status)

    25 {

    26   struct list_head *pos, *n;

    27   buddy_entry_t *tmp;

    28   int changed = 0;

    29   char *buffer = (char *) malloc(4096);

    30 

    31   list_for_each_safe(pos, n, &buddy_list) {

    32     tmp = buddy_entry(pos);

    33     if (!strcmp(tmp->jid, jidfrom)) {

    34       if (tmp->flags != status) {

    35 	tmp->flags = status;

    36 	changed = 1;

    37       }

    38       break;

    39     }

    40   }

    41   if (changed) {

    42     bud_DrawRoster(scr_GetRosterWindow());

    43     switch (status) {

    44     case FLAG_BUDDY_DISCONNECTED:

    45       sprintf(buffer, "--> %s %s!", jidfrom, i18n("disconected"));

    46       break;

    47 

    48     case FLAG_BUDDY_CONNECTED:

    49       sprintf(buffer, "--> %s %s!", jidfrom, i18n("connected"));

    50       break;

    51     }

    52     scr_WriteInWindow(i18n("status window"), buffer, TRUE);

    53   }

    54   free(buffer);

    55 }

    56 

    57 int compara(buddy_entry_t * t1, buddy_entry_t * t2)

    58 {

    59   const char *s1 =

    60       (const char *) (STR_EMPTY(t1->name) ? t1->jid : t1->name);

    61   const char *s2 =

    62       (const char *) (STR_EMPTY(t2->name) ? t2->jid : t2->name);

    63   return strcasecmp(s1, s2);

    64 }

    65 

    66 void bud_SortRoster(void)

    67 {

    68   buddy_entry_t *indice, *tmp;

    69   struct list_head *pos, *n;

    70 

    71   while (!list_empty(&buddy_list)) {

    72     indice = NULL;

    73     tmp = NULL;

    74     list_for_each_safe(pos, n, &buddy_list) {

    75       if (!indice) {

    76 	indice = buddy_entry(pos);

    77 	tmp = buddy_entry(pos);

    78       } else {

    79 	tmp = buddy_entry(pos);

    80 	if (compara(indice, tmp) > 0) {

    81 	  indice = tmp;

    82 	}

    83       }

    84     }

    85     list_move_tail(&indice->list, &sorted_buddies);

    86   }

    87   list_splice(&sorted_buddies, &buddy_list);

    88 }

    89 

    90 void bud_ParseBuddies(char *roster)

    91 {

    92   buddy_entry_t *tmp = NULL;

    93   char *aux;

    94   char *p, *str;

    95 

    96   ut_WriteLog("[roster]: %s\n\n", roster);

    97 

    98   while ((aux = ut_strrstr(roster, "<item")) != NULL) {

    99     char *jid = getattr(aux, "jid='");

   100     char *name = getattr(aux, "name='");

   101     char *group = gettag(aux, "group='");

   102 

   103     *aux = '\0';

   104 

   105     tmp = (buddy_entry_t *) calloc(1, sizeof(buddy_entry_t));

   106 

   107     tmp->flags = FLAG_BUDDY_DISCONNECTED;

   108 

   109     if (strncmp(jid, "UNK", 3)) {

   110       char *res = strstr(jid, "/");

   111       if (res)

   112 	*res = '\0';

   113 

   114       tmp->jid = (char *) malloc(strlen(jid) + 1);

   115       strcpy(tmp->jid, jid);

   116       free(jid);

   117     }

   118 

   119     if (strncmp(name, "UNK", 3)) {

   120       tmp->name = (char *) calloc(1, strlen(name) + 1);

   121       strcpy(tmp->name, name);

   122       free(name);

   123     } else {

   124       tmp->name = (char *) calloc(1, strlen(tmp->jid) + 1);

   125       str = strdup(tmp->jid);

   126       p = strstr(str, "@");

   127       if (p) {

   128 	*p = '\0';

   129       }

   130       strncpy(tmp->name, str, 18);

   131       free(str);

   132     }

   133 

   134     if (strncmp(group, "UNK", 3)) {

   135       tmp->group = (char *) malloc(strlen(group) + 1);

   136       strcpy(tmp->group, group);

   137       free(group);

   138     }

   139 

   140     if (!strncmp(tmp->jid, "msn.", 4)) {

   141       sprintf(tmp->name, "%c MSN %c", 254, 254);

   142     }

   143 

   144     if (!STR_EMPTY(tmp->jid)) {

   145       list_add_tail(&tmp->list, &buddy_list);

   146     } else {

   147       if (tmp->jid)

   148 	free(tmp->jid);

   149       if (tmp->name)

   150 	free(tmp->name);

   151       if (tmp->group)

   152 	free(tmp->group);

   153       free(tmp);

   154     }

   155   }

   156   free(roster);

   157 

   158   bud_SortRoster();

   159 }

   160 

   161 /* Desc: Initialize buddy list

   162  * 

   163  * In : none

   164  * Out: none

   165  *

   166  * Note: none

   167  */

   168 void bud_InitBuddies(int sock)

   169 {

   170   char *roster;

   171   roster = srv_getroster(sock);

   172   bud_ParseBuddies(roster);

   173 }

   174 

   175 /* Desc: Destroy (and free) buddy list

   176  * 

   177  * In : none

   178  * Out: none

   179  *

   180  * Note: none

   181  */

   182 void bud_TerminateBuddies(void)

   183 {

   184 }

   185 

   186 /* Desc: Count elements in buddy list

   187  * 

   188  * In : none

   189  * Out: number of buddies

   190  *

   191  * Note: none

   192  */

   193 int bud_BuddyCount(void)

   194 {

   195   int i = 0;

   196   struct list_head *pos, *n;

   197 

   198   list_for_each_safe(pos, n, &buddy_list) {

   199     i++;

   200   }

   201   return i;

   202 }

   203 

   204 /* Desc: Draw the roster in roster window

   205  * 

   206  * In : roster window

   207  * Out: none

   208  *

   209  * Note: none

   210  */

   211 void bud_DrawRoster(WINDOW * win)

   212 {

   213   buddy_entry_t *tmp = NULL;

   214   struct list_head *pos, *nn;

   215   int i = 1;

   216   int n;

   217   int maxx, maxy;

   218   int fakeOffset = buddyOffset;

   219 

   220   keypad(win, TRUE);

   221   getmaxyx(win, maxy, maxx);

   222 

   223 

   224   /* cleanup of roster window */

   225   wattrset(win, COLOR_PAIR(COLOR_GENERAL));

   226   for (i = 1; i < maxy - 1; i++) {

   227     mvwprintw(win, i, 1, "");

   228     for (n = 2; n < maxx; n++)

   229       waddch(win, ' ');

   230   }

   231 

   232   i = 1;

   233   list_for_each_safe(pos, nn, &buddy_list) {

   234 

   235     if (fakeOffset > 0) {

   236       fakeOffset--;

   237       continue;

   238     }

   239 

   240     tmp = buddy_entry(pos);

   241 

   242     if ((tmp->flags && FLAG_BUDDY_CONNECTED) == 1) {

   243       if (i == (buddySelected - buddyOffset))

   244 	wattrset(win, COLOR_PAIR(COLOR_BD_CONSEL));

   245       else

   246 	wattrset(win, COLOR_PAIR(COLOR_BD_CON));

   247     } else {

   248       if (i == (buddySelected - buddyOffset))

   249 	wattrset(win, COLOR_PAIR(COLOR_BD_DESSEL));

   250       else

   251 	wattrset(win, COLOR_PAIR(COLOR_BD_DES));

   252     }

   253     mvwprintw(win, i, 1, "");

   254     for (n = 2; n < maxx; n++)

   255       waddch(win, ' ');

   256     mvwprintw(win, i, (maxx - strlen(tmp->name)) / 2, "%s", tmp->name);

   257     i++;

   258     if (i >= maxy - 1)

   259       break;

   260   }

   261   update_panels();

   262   doupdate();

   263 }

   264 

   265 /* Desc: Change selected buddy (one position down)

   266  * 

   267  * In : none

   268  * Out: none

   269  *

   270  * Note: none

   271  */

   272 void bud_RosterDown(void)

   273 {

   274   int x, y;

   275   getmaxyx(scr_GetRosterWindow(), y, x);

   276   y -= 2;

   277 

   278   if (buddySelected < bud_BuddyCount()) {

   279     buddySelected++;

   280     if (buddySelected > y)

   281       buddyOffset++;

   282     bud_DrawRoster(scr_GetRosterWindow());

   283   }

   284 }

   285 

   286 /* Desc: Change selected buddy (one position up)

   287  * 

   288  * In : none

   289  * Out: none

   290  *

   291  * Note: none

   292  */

   293 void bud_RosterUp(void)

   294 {

   295   if (buddySelected > 1) {

   296     buddySelected--;

   297     if (buddySelected - buddyOffset < 1)

   298       buddyOffset--;

   299     bud_DrawRoster(scr_GetRosterWindow());

   300   }

   301 }

   302 

   303 /* Desc: Retrieve info for selected buddy

   304  * 

   305  * In : none

   306  * Out: (buddy_entry_t *) of selected buddy

   307  *

   308  * Note: none

   309  */

   310 buddy_entry_t *bud_SelectedInfo(void)

   311 {

   312   struct list_head *pos, *n;

   313   buddy_entry_t *tmp = NULL;

   314 

   315   int i = 0;

   316 

   317   list_for_each_safe(pos, n, &buddy_list) {

   318     tmp = buddy_entry(pos);

   319     if (i == buddySelected - 1) {

   320       return tmp;

   321     }

   322     i++;

   323   }

   324   return NULL;

   325 }

   326 

   327 void bud_AddBuddy(int sock)

   328 {

   329   char *buffer = (char *) calloc(1, 1024);

   330   char *buffer2 = (char *) calloc(1, 1024);

   331   char *p, *str;

   332   buddy_entry_t *tmp;

   333 

   334   ut_CenterMessage(i18n("write jid here"), 60, buffer2);

   335   scr_CreatePopup(i18n("Add jid"), buffer2, 60, 1, buffer);

   336 

   337   if (!STR_EMPTY(buffer)) {

   338     tmp = (buddy_entry_t *) calloc(1, sizeof(buddy_entry_t));

   339     tmp->jid = (char *) malloc(strlen(buffer) + 1);

   340     strcpy(tmp->jid, buffer);

   341     tmp->name = (char *) malloc(strlen(buffer) + 1);

   342 

   343     str = strdup(buffer);

   344     p = strstr(str, "@");

   345     if (p) {

   346       *p = '\0';

   347     }

   348     strcpy(tmp->name, str);

   349     free(str);

   350 

   351     list_add_tail(&tmp->list, &buddy_list);

   352     buddySelected = 1;

   353     bud_DrawRoster(scr_GetRosterWindow());

   354     srv_AddBuddy(sock, tmp->jid);

   355   }

   356   free(buffer);

   357 }

   358 

   359 void bud_DeleteBuddy(int sock)

   360 {

   361   buddy_entry_t *tmp = bud_SelectedInfo();

   362   srv_DelBuddy(sock, tmp->jid);

   363   list_del(&tmp->list);

   364   buddySelected = 1;

   365   bud_DrawRoster(scr_GetRosterWindow());

   366 }