mcabber/src/main.c
changeset 35 a8ceaa3005fd
parent 30 4ea2df449381
child 36 8f1a5e79ca40
equal deleted inserted replaced
34:f78ffe7ce43d 35:a8ceaa3005fd
     9 #include "utils.h"
     9 #include "utils.h"
    10 #include "screen.h"
    10 #include "screen.h"
    11 #include "buddies.h"
    11 #include "buddies.h"
    12 #include "parsecfg.h"
    12 #include "parsecfg.h"
    13 #include "lang.h"
    13 #include "lang.h"
    14 #include "server.h"
       
    15 #include "harddefines.h"
    14 #include "harddefines.h"
    16 #include "socket.h"
       
    17 #include "jabglue.h"
    15 #include "jabglue.h"
    18 
    16 
    19 //int sock;
    17 //int sock;
    20 
    18 
    21 void sig_handler(int signum)
    19 void sig_handler(int signum)
    26     break;
    24     break;
    27 
    25 
    28   case SIGTERM:
    26   case SIGTERM:
    29     bud_TerminateBuddies();
    27     bud_TerminateBuddies();
    30     scr_TerminateCurses();
    28     scr_TerminateCurses();
    31     // TODO srv_setpresence(sock, "unavailable");
    29     jb_disconnect();
    32     // TODO close(sock);
       
    33     printf("Killed by SIGTERM\nBye!\n");
    30     printf("Killed by SIGTERM\nBye!\n");
    34     exit(EXIT_SUCCESS);
    31     exit(EXIT_SUCCESS);
    35     break;
    32     break;
    36 
    33 
    37   }
    34   }
    58   (void) tcsetattr(fileno(stdin), TCSAFLUSH, &orig);
    55   (void) tcsetattr(fileno(stdin), TCSAFLUSH, &orig);
    59 
    56 
    60   return (ssize_t)nread;
    57   return (ssize_t)nread;
    61 }
    58 }
    62 
    59 
       
    60 char *compose_jid(const char *username, const char *servername,
       
    61         const char *resource)
       
    62 {
       
    63   char *jid = malloc(strlen(username)+strlen(servername)+strlen(resource)+3);
       
    64   strcpy(jid, username);
       
    65   strcat(jid, "@");
       
    66   strcat(jid, servername);
       
    67   strcat(jid, "/");
       
    68   strcat(jid, resource);
       
    69   return jid;
       
    70 }
       
    71 
    63 void credits(void)
    72 void credits(void)
    64 {
    73 {
    65   printf(VERSION "\n");
    74   printf(VERSION "\n");
    66   printf(EMAIL "\n");
    75   printf(EMAIL "\n");
    67 }
    76 }
    69 int main(int argc, char **argv)
    78 int main(int argc, char **argv)
    70 {
    79 {
    71   char configFile[4096];
    80   char configFile[4096];
    72   char *username, *password, *resource;
    81   char *username, *password, *resource;
    73   char *servername;
    82   char *servername;
    74   //char *idsession;
    83   char *jid;
    75   char *portstring;
    84   char *portstring;
    76   int key;
    85   int key;
    77   unsigned int port;
    86   unsigned int port;
    78   unsigned int ping;
    87   unsigned int ping;
    79   int ret = 0;
    88   int ret = 0;
   146   scr_InitCurses();
   155   scr_InitCurses();
   147 
   156 
   148   ut_WriteLog("Drawing main window...\n");
   157   ut_WriteLog("Drawing main window...\n");
   149   scr_DrawMainWindow();
   158   scr_DrawMainWindow();
   150 
   159 
   151   /* Connect to server */
       
   152   portstring = cfg_read("port");
   160   portstring = cfg_read("port");
   153   port = (portstring != NULL) ? (unsigned int) atoi(portstring) : -1U;
   161   port = (portstring != NULL) ? (unsigned int) atoi(portstring) : -1U;
   154 
   162 
       
   163   /* Connect to server */
   155   ut_WriteLog("Connecting to server: %s:%d\n", servername, port);
   164   ut_WriteLog("Connecting to server: %s:%d\n", servername, port);
   156   scr_LogPrint("Connecting to server: %s:%d", servername, port);
   165   scr_LogPrint("Connecting to server: %s:%d", servername, port);
   157   jc = jb_connect(servername, port, 0, username, password, resource);
   166 
       
   167   jid = compose_jid(username, servername, resource);
       
   168   jc = jb_connect(jid, port, 0, password);
       
   169   free(jid);
   158   if (!jc) {
   170   if (!jc) {
   159     ut_WriteLog("\terror!!!\n");
   171     ut_WriteLog("\terror!!!\n");
   160     fprintf(stderr, "Error connecting to (%s)\n", servername);
   172     fprintf(stderr, "Error connecting to (%s)\n", servername);
   161     scr_TerminateCurses();
   173     scr_TerminateCurses();
   162     return -2;
   174     return -2;
   176   ut_WriteLog("Ping interval stablished: %d secs\n", ping);
   188   ut_WriteLog("Ping interval stablished: %d secs\n", ping);
   177 
   189 
   178   ut_WriteLog("Entering into main loop...\n\n");
   190   ut_WriteLog("Entering into main loop...\n\n");
   179   ut_WriteLog("Ready to send/receive messages...\n");
   191   ut_WriteLog("Ready to send/receive messages...\n");
   180 
   192 
   181   sleep(1);
       
   182   jb_main();
       
   183   sleep(1);
       
   184   jb_main();
       
   185   sleep(2);
       
   186   jb_disconnect();
       
   187   sleep(1);
       
   188   jb_main();
       
   189   scr_TerminateCurses(); exit(0); // XXX
       
   190   while (ret != 255) {
   193   while (ret != 255) {
   191     int x;
       
   192     alarm(ping);
   194     alarm(ping);
   193     //x = check_io(sock, 0);
   195     keypad(scr_GetInputWindow(), TRUE);
   194     x = check_io(0, 0); // FIXME
   196     key = scr_Getch();
   195     /*
   197     if (key != ERR)
   196     if ((x & 1) == 1) {
       
   197       srv_msg *incoming = readserver(sock);
       
   198 
       
   199       switch (incoming->m) {
       
   200       case SM_PRESENCE:
       
   201 	bud_SetBuddyStatus(incoming->from, incoming->connected);
       
   202 	break;
       
   203 
       
   204       case SM_MESSAGE:
       
   205 	scr_WriteIncomingMessage(incoming->from, incoming->body);
       
   206 	free(incoming->body);
       
   207 	free(incoming->from);
       
   208 	break;
       
   209 
       
   210       case SM_UNHANDLED:
       
   211 	break;
       
   212       }
       
   213       free(incoming);
       
   214     }
       
   215     if ((x & 2) == 2) {
       
   216     */
       
   217     if (x) {
       
   218       keypad(scr_GetInputWindow(), TRUE);
       
   219       key = scr_Getch();
       
   220       ret = process_key(key);
   198       ret = process_key(key);
   221       /*
   199     jb_main();
   222       switch (key) {
       
   223       case KEY_IC:
       
   224 	bud_AddBuddy(sock);
       
   225 	break;
       
   226       case KEY_DC:
       
   227 	bud_DeleteBuddy(sock);
       
   228 	break;
       
   229 
       
   230       case KEY_RESIZE:
       
   231 	endwin();
       
   232 	printf("\nRedimensionado no implementado\n");
       
   233 	printf("Reinicie Cabber.\n\n\n");
       
   234 	exit(EXIT_FAILURE);
       
   235 	break;
       
   236       }
       
   237       */
       
   238     }
       
   239     if (update_roster) {
   200     if (update_roster) {
   240       // scr_LogPrint("Update roster");
   201       // scr_LogPrint("Update roster");
   241       bud_DrawRoster(scr_GetRosterWindow());
   202       bud_DrawRoster(scr_GetRosterWindow());
   242     }
   203     }
   243   }
   204   }
   244 
   205 
       
   206   jb_disconnect();
   245   bud_TerminateBuddies();
   207   bud_TerminateBuddies();
   246   scr_TerminateCurses();
   208   scr_TerminateCurses();
   247 
   209 
   248   //srv_setpresence(sock, "unavailable");
   210   //srv_setpresence(sock, "unavailable");
   249   //close(sock);
   211   //close(sock);