Jabber WindowGram Client (JWGC)

Introduction Screenshots Installation Downloads
Documentation Browse Source Resources Project Site

Stable Version
-none-

Latest Version
beta5



Main Page | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals

libjwgc.h File Reference

#include <sysdep.h>
#include "libxode.h"
#include "libjwgc_types.h"
#include "libjwgc_debug.h"
#include "libjabber_types.h"

Go to the source code of this file.

Defines

#define _LIBJWGC_H_   1

Functions

void JGenerateAuth ()
int JCheckAuth (char *str)
char * JGetAuth ()
int contact_status_change (jabpacket packet)
char * find_nickname_from_jid (char *jid)
char * find_jid_from_nickname (char *nickname)
void list_contacts (jwgconn jwg, char *matchstr, int strictmatch, int skipnotavail)
void list_contacts_bygroup (jwgconn jwg, char *matchstr, int strictmatch, int skipnotavail)
void list_agents (xode x)
int update_contact_status (char *jid, char *status, char *resource)
void update_nickname (char *target, char *nickname)
void update_group (char *target, char *group)
void remove_from_contact_list (char *contact)
int test_match (char *matchstr, xode contact, int exactmatch)
char * find_match (char *searchstr)
void insert_into_agent_list (char *jid, char *name, char *service, int flags)
void expat_startElement (void *userdata, const char *name, const char **atts)
void expat_endElement (void *userdata, const char *name)
void expat_charData (void *userdata, const char *s, int len)
xode xode_str (char *str, int len)
xode xode_file (char *file)
int xode2file (char *file, xode node)
void xode_put_expat_attribs (xode owner, const char **atts)
int JSaveAuthPort ()
int JGetAuthPort ()
void JClearAuthPort ()
int JSetupComm ()
int JConnect ()
void JCleanupSocket ()
xode JFormHandler (xode form)
NAMEDlookup (HASH_TABLE *table, KEY name, size_t createSize)
void hashTableInit (HASH_TABLE *)
void hashTableDestroy (HASH_TABLE *)
void hashTableIterInit (HASH_TABLE_ITER *, const HASH_TABLE *)
NAMEDhashTableIterNext (HASH_TABLE_ITER *)
int make_netsocket (u_short port, char *host, int type)
int get_netport ()
in_addr * make_addr (char *host)
int set_fd_close_on_exec (int fd, int flag)
void j_shaInit (j_SHA_CTX *ctx)
void j_shaUpdate (j_SHA_CTX *ctx, unsigned char *dataIn, int len)
void j_shaFinal (j_SHA_CTX *ctx, unsigned char hashout[20])
void j_shaBlock (unsigned char *dataIn, int len, unsigned char hashout[20])
char * j_shahash (char *str)
void j_shahash_r (const char *str, char hashbuf[41])
char * j_strdup (const char *str)
char * j_strcat (char *dest, char *txt)
int j_strcmp (const char *a, const char *b)
int j_strcasecmp (const char *a, const char *b)
int j_strncmp (const char *a, const char *b, int i)
int j_strncasecmp (const char *a, const char *b, int i)
int j_strlen (const char *a)
int j_atoi (const char *a, int def)
void str_b64decode (char *str)
void trim_message (char *str)
xode_spool spool_new (xode_pool p)
void spooler (xode_spool s,...)
char * spool_print (xode_spool s)
void spool_add (xode_spool s, char *str)
char * spools (xode_pool p,...)
int unicode_to_str (const char *in, char **out)
int str_to_unicode (const char *in, char **out)
int str_clear_unprintable (const char *in, char **out)
int jVars_set_personal_var (char *var, char *value)
int jVars_inset_personal_var (char *var)
int jVars_init ()
void jVars_set_error (char *errstr)
char * jVars_get_error ()
void jVars_set_change_handler (jVar jvar, void(*handler)())
void jVars_set_check_handler (jVar jvar, int(*handler)())
void jVars_set_show_handler (jVar jvar, int(*handler)())
void jVars_set_defaults_handler (void(*handler)())
void * jVars_get (jVar name)
char * jVars_show (jVar name)
int jVars_set (jVar name, void *setting)
char * jVars_itos (jVar jvar)
jVar jVars_stoi (char *jvar)
void jVars_read_defaults ()
jwgpacket jwgpacket_new (xode x)
jwgpacket jwgpacket_reset (jwgpacket p)
jwgconn jwg_new ()
void jwg_delete (jwgconn j)
void jwg_packet_handler (jwgconn j, jwgconn_packet_h h)
void jwg_start (jwgconn j)
void jwg_stop (jwgconn j)
int jwg_getfd (jwgconn j)
void jwg_send (jwgconn j, xode x)
void jwg_servsend (jwgconn j, xode x)
void jwg_send_raw (jwgconn j, const char *str)
void jwg_servsend_raw (jwgconn j, const char *str)
void jwg_recv (jwgconn j)
void jwg_servrecv (jwgconn j)
void jwg_servsuccess (jwgconn jwg, char *text)
void jwg_serverror (jwgconn jwg, char *text)
void jwg_poll (jwgconn j, int timeout)
void jwg_servpoll (jwgconn j, int timeout)
jwgconn jwg_server ()


Define Documentation

#define _LIBJWGC_H_   1
 

Definition at line 4 of file libjwgc.h.


Function Documentation

int contact_status_change jabpacket  packet  ) 
 

Definition at line 190 of file JContact.c.

References dExecution, dprintf(), jabpacket, JABPACKET__AVAILABLE, JABPACKET__UNAVAILABLE, jabpacket_struct::subtype, update_contact_status(), jabpacket_struct::x, xode, xode_get_attrib(), xode_get_data(), and xode_get_tag().

Referenced by process_presence().

00191 {
00192         char *temp, *pos;
00193         xode x;
00194         char *from = xode_get_attrib(packet->x, "from");
00195         char *resource = "NULL";
00196         int ret = 0;
00197         if (!from) {
00198                 return;
00199         }
00200 
00201         pos = (char *) strchr(from, '/');
00202         if (pos) {
00203                 *pos = '\0';
00204                 resource = pos + 1;
00205         }
00206 
00207         switch (packet->subtype) {
00208                 case JABPACKET__AVAILABLE:
00209                         x = xode_get_tag(packet->x, "show");
00210                         if (x) {
00211                                 temp = xode_get_data(x);
00212                                 update_contact_status(from, temp, resource);
00213                                 ret = 1;
00214                         }
00215                         else {
00216                                 update_contact_status(from, "available", resource);
00217                                 ret = 1;
00218                         }
00219 
00220                         dprintf(dExecution, "%s is available\n", from);
00221                         break;
00222 
00223                 case JABPACKET__UNAVAILABLE:
00224                         dprintf(dExecution, "%s is unavailable\n", from);
00225                         update_contact_status(from, "unavailable", resource);
00226                         ret = 1;
00227                         break;
00228 
00229                 default:
00230                         dprintf(dExecution, "%s is unknown(?) -> %d\n", from, packet->subtype);
00231                         update_contact_status(from, "unknown", resource);
00232                         ret = 1;
00233                         break;
00234         }
00235 }

void expat_charData void *  userdata,
const char *  s,
int  len
 

Definition at line 81 of file JExpat.c.

References xode, and xode_insert_cdata().

Referenced by xode_file(), and xode_str().

00082 {
00083         xode *x = userdata;
00084         xode current = *x;
00085 
00086         xode_insert_cdata(current, s, len);
00087 }

void expat_endElement void *  userdata,
const char *  name
 

Definition at line 67 of file JExpat.c.

References xode_struct::complete, xode, and xode_get_parent().

Referenced by xode_file(), and xode_str().

00068 {
00069         xode *x = userdata;
00070         xode current = *x;
00071 
00072         current->complete = 1;
00073         current = xode_get_parent(current);
00074 
00075         /* if it's NULL we've hit the top folks, otherwise back up a level */
00076         if (current != NULL)
00077                 *x = current;
00078 }

void expat_startElement void *  userdata,
const char *  name,
const char **  atts
 

Definition at line 48 of file JExpat.c.

References atts, xode, xode_insert_tag(), xode_new(), and xode_put_expat_attribs().

Referenced by xode_file(), and xode_str().

00049 {
00050         /* get the xode pointed to by the userdata */
00051         xode *x = userdata;
00052         xode current = *x;
00053 
00054         if (current == NULL) {
00055                 /* allocate a base node */
00056                 current = xode_new(name);
00057                 xode_put_expat_attribs(current, atts);
00058                 *x = current;
00059         }
00060         else {
00061                 *x = xode_insert_tag(current, name);
00062                 xode_put_expat_attribs(*x, atts);
00063         }
00064 }

char* find_jid_from_nickname char *  nickname  ) 
 

Definition at line 461 of file JContact.c.

References contact_list, and xode_get_attrib().

00462 {
00463         int i;
00464         char *name;
00465 
00466         for (i = 0; i < num_contacts; i++) {
00467                 name = xode_get_attrib(contact_list[i], "nick");
00468                 if (name && !strcasecmp(name, nickname)) {
00469                         return strdup(xode_get_attrib(contact_list[i], "jid"));
00470                 }
00471         }
00472 
00473         return NULL;
00474 }

char* find_match char *  searchstr  ) 
 

Definition at line 524 of file JContact.c.

References contact_list, dMatch, dprintf(), jid, and xode_get_attrib().

Referenced by jwg_on_event_handler().

00525 {
00526         int i;
00527         char *jid, *nick;
00528 
00529         /* Try exact jid match */
00530         for (i = 0; i < num_contacts; i++) {
00531                 jid = xode_get_attrib(contact_list[i], "jid");
00532                 dprintf(dMatch, "Exact Match: %s = %s\n", searchstr, jid);
00533                 if (!strcasecmp(jid, searchstr)) {
00534                         return strdup(jid);
00535                 }
00536         }
00537 
00538         /* Try exact nickname match */
00539         for (i = 0; i < num_contacts; i++) {
00540                 jid = xode_get_attrib(contact_list[i], "jid");
00541                 nick = xode_get_attrib(contact_list[i], "nick");
00542                 if (!nick) {
00543                         continue;
00544                 }
00545                 dprintf(dMatch, "Nick Match: %s = %s\n", searchstr, nick);
00546                 if (!strcasecmp(nick, searchstr)) {
00547                         return strdup(jid);
00548                 }
00549         }
00550 
00551         /* Try begging of jid match */
00552         for (i = 0; i < num_contacts; i++) {
00553                 jid = xode_get_attrib(contact_list[i], "jid");
00554                 dprintf(dMatch, "Part Match: %s = %s\n", searchstr, jid);
00555                 if (!strncasecmp(jid, searchstr, strlen(searchstr))) {
00556                         return strdup(jid);
00557                 }
00558         }
00559 
00560         /* No matches, sorry */
00561         return NULL;
00562 }

char* find_nickname_from_jid char *  jid  ) 
 

Definition at line 477 of file JContact.c.

References contact_list, jid, and xode_get_attrib().

Referenced by decode_notice().

00478 {
00479         int i;
00480         char *name, *nick;
00481 
00482         for (i = 0; i < num_contacts; i++) {
00483                 name = xode_get_attrib(contact_list[i], "jid");
00484                 if (name && !strcasecmp(name, jid)) {
00485                         nick = xode_get_attrib(contact_list[i], "nick");
00486                         if (nick) {
00487                                 return strdup(nick);
00488                         }
00489                         else {
00490                                 return strdup("");
00491                         }
00492                 }
00493         }
00494 
00495         return NULL;
00496 }

int get_netport  ) 
 

Definition at line 57 of file JNetSock.c.

00058 {
00059         return __Xode_port;
00060 }

void hashTableDestroy HASH_TABLE  ) 
 

Definition at line 4286 of file xmlparse.c.

References XML_Memory_Handling_Suite::free_fcn, hashTableDestroy(), HASH_TABLE::mem, HASH_TABLE::size, and HASH_TABLE::v.

Referenced by hashTableDestroy().

04287 {
04288   size_t i;
04289   for (i = 0; i < table->size; i++) {
04290     NAMED *p = table->v[i];
04291     if (p)
04292       table->mem->free_fcn(p);
04293   }
04294   if (table->v)
04295     table->mem->free_fcn(table->v);
04296 }

void hashTableInit HASH_TABLE  ) 
 

Definition at line 120 of file JHashTable.c.

Referenced by hashTableInit().

00121 {
00122         p->size = 0;
00123         p->usedLim = 0;
00124         p->used = 0;
00125         p->v = 0;
00126 }

void hashTableIterInit HASH_TABLE_ITER ,
const HASH_TABLE
 

Definition at line 4309 of file xmlparse.c.

References HASH_TABLE_ITER::end, hashTableIterInit(), HASH_TABLE_ITER::p, HASH_TABLE::size, and HASH_TABLE::v.

Referenced by hashTableIterInit().

04310 {
04311   iter->p = table->v;
04312   iter->end = iter->p + table->size;
04313 }

NAMED * hashTableIterNext HASH_TABLE_ITER  ) 
 

Definition at line 4316 of file xmlparse.c.

References HASH_TABLE_ITER::end, hashTableIterNext(), and HASH_TABLE_ITER::p.

Referenced by hashTableIterNext().

04317 {
04318   while (iter->p != iter->end) {
04319     NAMED *tem = *(iter->p)++;
04320     if (tem)
04321       return tem;
04322   }
04323   return 0;
04324 }

void insert_into_agent_list char *  jid,
char *  name,
char *  service,
int  flags
 

Definition at line 79 of file JContact.c.

References agent_list, dExecution, dprintf(), jid, num_agents, xode, xode_get_attrib(), xode_insert_tag(), xode_new(), and xode_put_attrib().

Referenced by process_iq_result().

00080 {
00081         int i, k;
00082 
00083         if (!jid) {
00084                 return;
00085         }
00086 
00087         num_agents++;
00088         agent_list = realloc(agent_list, sizeof(xode) * (num_agents));
00089         agent_list[num_agents - 1] = malloc(sizeof(xode));
00090 
00091         for (i = 0; i < (num_agents - 1) &&
00092              (strcasecmp(jid, xode_get_attrib(agent_list[i], "jid")) > 0);
00093              i++);
00094 
00095         for (k = (num_agents - 1); k > i; k--) {
00096                 agent_list[k] = agent_list[k - 1];
00097         }
00098 
00099         agent_list[k] = xode_new("agent");
00100         xode_put_attrib(agent_list[k], "jid", jid);
00101         if (name) {
00102                 xode_put_attrib(agent_list[k], "name", name);
00103         }
00104         if (service) {
00105                 xode_put_attrib(agent_list[k], "service", service);
00106         }
00107         if (flags & AGENT_TRANSPORT) {
00108                 xode_insert_tag(agent_list[k], "transport");
00109         }
00110         if (flags & AGENT_GROUPCHAT) {
00111                 xode_insert_tag(agent_list[k], "groupchat");
00112         }
00113         if (flags & AGENT_REGISTER) {
00114                 xode_insert_tag(agent_list[k], "register");
00115         }
00116         if (flags & AGENT_SEARCH) {
00117                 xode_insert_tag(agent_list[k], "search");
00118         }
00119 
00120         dprintf(dExecution, "Inserted %s into agent list at positiion %d\n", jid, i);
00121 }

int j_atoi const char *  a,
int  def
 

Definition at line 141 of file JStr.c.

00142 {
00143         if (a == NULL)
00144                 return def;
00145         else
00146                 return atoi(a);
00147 }

void j_shaBlock unsigned char *  dataIn,
int  len,
unsigned char  hashout[20]
 

Definition at line 110 of file JSha.c.

References j_shaFinal(), j_shaInit(), and j_shaUpdate().

Referenced by j_shahash(), and j_shahash_r().

00111 {
00112         j_SHA_CTX ctx;
00113 
00114         j_shaInit(&ctx);
00115         j_shaUpdate(&ctx, dataIn, len);
00116         j_shaFinal(&ctx, hashout);
00117 }

void j_shaFinal j_SHA_CTX ctx,
unsigned char  hashout[20]
 

Definition at line 71 of file JSha.c.

References j_SHA_CTX::H, j_shaInit(), j_shaUpdate(), j_SHA_CTX::lenW, j_SHA_CTX::sizeHi, and j_SHA_CTX::sizeLo.

Referenced by j_shaBlock().

00072 {
00073         unsigned char pad0x80 = 0x80;
00074         unsigned char pad0x00 = 0x00;
00075         unsigned char padlen[8];
00076         int i;
00077 
00078         /*
00079          * Pad with a binary 1 (e.g. 0x80), then zeroes, then length
00080          */
00081         padlen[0] = (unsigned char) ((ctx->sizeHi >> 24) & 255);
00082         padlen[1] = (unsigned char) ((ctx->sizeHi >> 16) & 255);
00083         padlen[2] = (unsigned char) ((ctx->sizeHi >> 8) & 255);
00084         padlen[3] = (unsigned char) ((ctx->sizeHi >> 0) & 255);
00085         padlen[4] = (unsigned char) ((ctx->sizeLo >> 24) & 255);
00086         padlen[5] = (unsigned char) ((ctx->sizeLo >> 16) & 255);
00087         padlen[6] = (unsigned char) ((ctx->sizeLo >> 8) & 255);
00088         padlen[7] = (unsigned char) ((ctx->sizeLo >> 0) & 255);
00089         j_shaUpdate(ctx, &pad0x80, 1);
00090         while (ctx->lenW != 56)
00091                 j_shaUpdate(ctx, &pad0x00, 1);
00092         j_shaUpdate(ctx, padlen, 8);
00093 
00094         /*
00095          * Output hash
00096          */
00097         for (i = 0; i < 20; i++) {
00098                 hashout[i] = (unsigned char) (ctx->H[i / 4] >> 24);
00099                 ctx->H[i / 4] <<= 8;
00100         }
00101 
00102         /*
00103          *  Re-initialize the context (also zeroizes contents)
00104          */
00105         j_shaInit(ctx);
00106 }

char* j_shahash char *  str  ) 
 

Definition at line 184 of file JSha.c.

References j_shaBlock(), and snprintf.

Referenced by jab_auth(), and jabutil_regkey().

00185 {
00186         static char final[41];
00187         char *pos;
00188         unsigned char hashval[20];
00189         int x;
00190 
00191         if (!str || strlen(str) == 0)
00192                 return NULL;
00193 
00194         j_shaBlock((unsigned char *) str, strlen(str), hashval);
00195 
00196         pos = final;
00197         for (x = 0; x < 20; x++) {
00198                 snprintf(pos, 3, "%02x", hashval[x]);
00199                 pos += 2;
00200         }
00201         return (char *) final;
00202 }

void j_shahash_r const char *  str,
char  hashbuf[41]
 

Definition at line 205 of file JSha.c.

References j_shaBlock(), and snprintf.

00206 {
00207         int x;
00208         char *pos;
00209         unsigned char hashval[20];
00210 
00211         if (!str || strlen(str) == 0)
00212                 return;
00213 
00214         j_shaBlock((unsigned char *) str, strlen(str), hashval);
00215 
00216         pos = hashbuf;
00217         for (x = 0; x < 20; x++) {
00218                 snprintf(pos, 3, "%02x", hashval[x]);
00219                 pos += 2;
00220         }
00221 
00222         return;
00223 }

void j_shaInit j_SHA_CTX ctx  ) 
 

Definition at line 28 of file JSha.c.

References j_SHA_CTX::H, j_SHA_CTX::lenW, j_SHA_CTX::sizeHi, j_SHA_CTX::sizeLo, and j_SHA_CTX::W.

Referenced by j_shaBlock(), and j_shaFinal().

00029 {
00030         int i;
00031 
00032         ctx->lenW = 0;
00033         ctx->sizeHi = ctx->sizeLo = 0;
00034 
00035         /*
00036          * Initialize H with the magic constants (see FIPS180 for constants)
00037          */
00038         ctx->H[0] = 0x67452301L;
00039         ctx->H[1] = 0xefcdab89L;
00040         ctx->H[2] = 0x98badcfeL;
00041         ctx->H[3] = 0x10325476L;
00042         ctx->H[4] = 0xc3d2e1f0L;
00043 
00044         for (i = 0; i < 80; i++)
00045                 ctx->W[i] = 0;
00046 }

void j_shaUpdate j_SHA_CTX ctx,
unsigned char *  dataIn,
int  len
 

Definition at line 50 of file JSha.c.

References j_SHA_CTX::lenW, j_SHA_CTX::sizeHi, j_SHA_CTX::sizeLo, and j_SHA_CTX::W.

Referenced by j_shaBlock(), and j_shaFinal().

00051 {
00052         int i;
00053 
00054         /*
00055          * Read the data into W and process blocks as they get full
00056          */
00057         for (i = 0; i < len; i++) {
00058                 ctx->W[ctx->lenW / 4] <<= 8;
00059                 ctx->W[ctx->lenW / 4] |= (unsigned long) dataIn[i];
00060                 if ((++ctx->lenW) % 64 == 0) {
00061                         j_shaHashBlock(ctx);
00062                         ctx->lenW = 0;
00063                 }
00064                 ctx->sizeLo += 8;
00065                 ctx->sizeHi += (ctx->sizeLo < 8);
00066         }
00067 }

int j_strcasecmp const char *  a,
const char *  b
 

Definition at line 105 of file JStr.c.

References NULL.

00106 {
00107         if (a == NULL || b == NULL)
00108                 return -1;
00109         else
00110                 return strcasecmp(a, b);
00111 }

char* j_strcat char *  dest,
char *  txt
 

Definition at line 75 of file JStr.c.

Referenced by spool_print().

00076 {
00077         if (!txt)
00078                 return (dest);
00079 
00080         while (*txt)
00081                 *dest++ = *txt++;
00082         *dest = '\0';
00083 
00084         return (dest);
00085 }

int j_strcmp const char *  a,
const char *  b
 

Definition at line 88 of file JStr.c.

References NULL.

Referenced by jabpacket_subtype(), and jabutil_regkey().

00089 {
00090         if (a == NULL || b == NULL)
00091                 return -1;
00092 
00093         while (*a == *b && *a != '\0' && *b != '\0') {
00094                 a++;
00095                 b++;
00096         }
00097 
00098         if (*a == *b)
00099                 return 0;
00100 
00101         return -1;
00102 }

char* j_strdup const char *  str  ) 
 

Definition at line 66 of file JStr.c.

00067 {
00068         if (str == NULL)
00069                 return NULL;
00070         else
00071                 return strdup(str);
00072 }

int j_strlen const char *  a  ) 
 

Definition at line 132 of file JStr.c.

00133 {
00134         if (a == NULL)
00135                 return 0;
00136         else
00137                 return strlen(a);
00138 }

int j_strncasecmp const char *  a,
const char *  b,
int  i
 

Definition at line 123 of file JStr.c.

References NULL.

00124 {
00125         if (a == NULL || b == NULL)
00126                 return -1;
00127         else
00128                 return strncasecmp(a, b, i);
00129 }

int j_strncmp const char *  a,
const char *  b,
int  i
 

Definition at line 114 of file JStr.c.

References NULL.

00115 {
00116         if (a == NULL || b == NULL)
00117                 return -1;
00118         else
00119                 return strncmp(a, b, i);
00120 }

int JCheckAuth char *  str  ) 
 

void JCleanupSocket  ) 
 

Definition at line 93 of file JFile.c.

References getenv().

Referenced by jabber_finalize().

00094 {
00095         char savefile[MAXNAMLEN];
00096         FILE *savefd;
00097         char *envptr;
00098 
00099         envptr = getenv("JWGCSCK");
00100         if (!envptr) {
00101                 (void) sprintf(savefile, "/tmp/jwgcsck.%d", getuid());
00102                 envptr = savefile;
00103         }
00104         unlink(envptr);
00105 }

void JClearAuthPort  ) 
 

int JConnect  ) 
 

Definition at line 54 of file JFile.c.

References getenv().

Referenced by jwg_start().

00055 {
00056         int sock;
00057         struct sockaddr_un sockaddr;
00058         char file[MAXNAMLEN];
00059         struct linger li;
00060         char *envptr;
00061 
00062         li.l_onoff = 1;
00063         li.l_linger = 900;
00064 
00065         sock = socket(AF_UNIX, SOCK_STREAM, 0);
00066         if (sock < 0) {
00067                 return -1;
00068         }
00069         envptr = getenv("JWGCSCK");
00070         if (!envptr) {
00071                 (void) sprintf(file, "/tmp/jwgcsck.%d", getuid());
00072                 envptr = file;
00073         }
00074         sockaddr.sun_family = AF_UNIX;
00075 
00076         strcpy(sockaddr.sun_path, envptr);
00077         if (connect(sock, (struct sockaddr *)&sockaddr,
00078                 strlen(sockaddr.sun_path)+1 + sizeof(sockaddr.sun_family))
00079                         < 0) {
00080                 return -1;
00081         }
00082 
00083         if (setsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&li, sizeof(li))
00084                         == -1) {
00085                 return -1;
00086         }
00087 
00088 
00089         return sock;
00090 }

xode JFormHandler xode  form  ) 
 

Definition at line 901 of file JForm.c.

References display_form(), ns, NS_DATA, process_choice(), xode, xode_get_attrib(), xode_get_tag(), xode_insert_tag(), xode_new(), and xode_put_attrib().

Referenced by jctl_on_event_handler().

00902 {
00903         xode baseform, filledform, query, x;
00904         char *ns, *type;
00905         char bfr[100];
00906 
00907         ns = xode_get_attrib(form, "xmlns");
00908         if (!ns) {
00909                 printf("Invalid form returned, no query namespace.\n");
00910                 return NULL;
00911         }
00912 
00913         baseform = xode_new("query");
00914         xode_put_attrib(baseform, "xmlns", ns);
00915 
00916         type = ns = NULL;
00917 
00918         x = xode_get_tag(form, "x");
00919         if (x) {
00920                 type = xode_get_attrib(x, "type");
00921         }
00922 
00923         if (type && !strcmp(type, "form")) {
00924                 filledform = xode_insert_tag(baseform, "x");
00925                 xode_put_attrib(filledform, "xmlns", NS_DATA);
00926                 xode_put_attrib(filledform, "type", "submit");
00927         }
00928         else {
00929                 filledform = baseform;
00930         }
00931 
00932         for (;;) {
00933                 filledform = display_form(form, filledform);
00934                 printf("\n");
00935                 printf("Enter a letter id to modify, 'submit' to submit, or 'cancel' to cancel.\n");
00936                 printf("Command: ");
00937                 fflush(stdout);
00938 
00939                 if (!fgets(bfr, sizeof(bfr), stdin)) {
00940                         break;
00941                 }
00942 
00943                 printf("\n");
00944                 bfr[strlen(bfr) - 1] = '\0';
00945 
00946                 if (!strncmp(bfr, "cancel", 6)) {
00947                         return NULL;
00948                 }
00949                 else if (!strncmp(bfr, "submit", 6)) {
00950                         break;
00951                 }
00952                 else if (strlen(bfr) > 1) {
00953                         continue;
00954                 }
00955                 else {
00956                         filledform = process_choice(bfr, form, filledform);
00957                 }
00958         }
00959 
00960         return baseform;
00961 }

void JGenerateAuth  ) 
 

char* JGetAuth  ) 
 

int JGetAuthPort  ) 
 

int JSaveAuthPort  ) 
 

int JSetupComm  ) 
 

Definition at line 7 of file JFile.c.

References getenv().

Referenced by jwg_servstart().

00008 {
00009         mode_t prevmode;
00010         int sock;
00011         struct sockaddr_un sockaddr;
00012         char file[MAXNAMLEN];
00013         struct linger li;
00014         char *envptr;
00015 
00016         li.l_onoff = 1;
00017         li.l_linger = 900;
00018 
00019         prevmode = umask(S_IRWXO|S_IRWXG);
00020         sock = socket(AF_UNIX, SOCK_STREAM, 0);
00021         if (sock < 0) {
00022                 return -1;
00023         }
00024         envptr = getenv("JWGCSCK");
00025         if (!envptr) {
00026                 (void) sprintf(file, "/tmp/jwgcsck.%d", getuid());
00027                 envptr = file;
00028         }
00029         unlink(envptr);
00030 
00031         sockaddr.sun_family = AF_UNIX;
00032         strcpy(sockaddr.sun_path, envptr);
00033         if (bind(sock, (struct sockaddr *)&sockaddr,
00034                 strlen(sockaddr.sun_path)+1 + sizeof(sockaddr.sun_family))
00035                         < 0) {
00036                 return -1;
00037         }
00038         if (listen(sock, 10) < 0) {
00039                 return -1;
00040         }
00041 
00042         if (setsockopt(sock, SOL_SOCKET, SO_LINGER, (char *)&li, sizeof(li))
00043                         == -1) {
00044                 return -1;
00045         }
00046 
00047 
00048         umask(prevmode);
00049 
00050         return sock;
00051 }

void* jVars_get jVar  name  ) 
 

Definition at line 293 of file JVariables.c.

References jNumVars, and jVars_contents.

Referenced by eval_expr(), fake_startup_packet(), jab_on_state_handler(), jabber_init(), jabutil_presnew(), jwg_on_event_handler(), jwgc_change_presence_event_handler(), main(), and run_initprogs().

00295 {
00296         if (name >= jNumVars || name < 0) {
00297                 return NULL;
00298         }
00299 
00300         if (jVars_contents[name]) {
00301                 return jVars_contents[name];
00302         }
00303         else {
00304                 return NULL;
00305         }
00306 }

char * jVars_get_error  ) 
 

Definition at line 251 of file JVariables.c.

Referenced by jwg_on_event_handler().

00252 {
00253         if (varerrorstr) {
00254                 return varerrorstr;
00255         }
00256         else {
00257                 return NULL;
00258         }
00259 }

int jVars_init  ) 
 

Definition at line 147 of file JVariables.c.

References DEFVARS, dprintf(), dVars, FIXEDVARS, getenv(), jVar, jVars_contents, jVars_fixed, jVars_read_defaults(), jVars_set_error(), jVars_strings, jVars_types, USRVARS, varerrorstr, varfiledefaults, varfilefixed, and varfilepersonal.

Referenced by main().

00148 {
00149         jVar i;
00150         struct passwd *pwd;
00151         char *envptr, *homedir;
00152 
00153         dprintf(dVars, "Initializing variable manager...\n");
00154 
00155         varfiledefaults = NULL;
00156         varfilefixed = NULL;
00157         varfilepersonal = NULL;
00158         varerrorstr = NULL;
00159 
00160         for (i = 0; i < jNumVars; i++) {
00161                 jVars_fixed[i] = 0;
00162                 jVars_contents[i] = NULL;
00163                 jVars_check_handler[i] = NULL;
00164                 jVars_change_handler[i] = NULL;
00165                 jVars_show_handler[i] = NULL;
00166         }
00167 
00168         if ((envptr = (char *) getenv("HOME"))) {
00169                 homedir = strdup(envptr);
00170         }
00171         else {
00172                 if (!(pwd = getpwuid((int) getuid()))) {
00173                         jVars_set_error("Can't find your entry in /etc/passwd.");
00174                         return 0;
00175                 }
00176                 homedir = strdup(pwd->pw_dir);
00177         }
00178 
00179         varfilepersonal = (char *)malloc(sizeof(char) *
00180                         (strlen(homedir) + 1 + strlen(USRVARS) + 1));
00181         strcpy(varfilepersonal, homedir);
00182         strcat(varfilepersonal, "/");
00183         strcat(varfilepersonal, USRVARS);
00184 
00185         varfilefixed = (char *)malloc(strlen(DATADIR) + strlen(FIXEDVARS) + 2);
00186         sprintf(varfilefixed, "%s/%s", DATADIR, FIXEDVARS);
00187 
00188         varfiledefaults = (char *)malloc(strlen(DATADIR) + strlen(DEFVARS) + 2);
00189         sprintf(varfiledefaults, "%s/%s", DATADIR, DEFVARS);
00190 
00191         jVars_strings[jVarUsername] = "username";
00192         jVars_types[jVarUsername] = jTypeString;
00193 
00194         jVars_strings[jVarPassword] = "password";
00195         jVars_types[jVarPassword] = jTypeString;
00196 
00197         jVars_strings[jVarServer] = "server";
00198         jVars_types[jVarServer] = jTypeString;
00199 
00200         jVars_strings[jVarResource] = "resource";
00201         jVars_types[jVarResource] = jTypeString;
00202 
00203         jVars_strings[jVarPort] = "port";
00204         jVars_types[jVarPort] = jTypeNumber;
00205 
00206         jVars_strings[jVarPriority] = "priority";
00207         jVars_types[jVarPriority] = jTypeNumber;
00208 
00209 #ifdef USE_SSL
00210         jVars_strings[jVarUseSSL] = "usessl";
00211         jVars_types[jVarUseSSL] = jTypeBool;
00212 #endif /* USE_SSL */
00213 
00214         jVars_strings[jVarInitProgs] = "initprogs";
00215         jVars_types[jVarInitProgs] = jTypeString;
00216 
00217         jVars_strings[jVarJID] = "jid";
00218         jVars_types[jVarJID] = jTypeString;
00219 
00220         jVars_strings[jVarPresence] = "presence";
00221         jVars_types[jVarPresence] = jTypeString;
00222 
00223 #ifdef USE_GPGME
00224         jVars_strings[jVarUseGPG] = "usegpg";
00225         jVars_types[jVarUseGPG] = jTypeBool;
00226 
00227         jVars_strings[jVarGPGPass] = "gpgpass";
00228         jVars_types[jVarGPGPass] = jTypeString;
00229 
00230         jVars_strings[jVarGPGKeyID] = "gpgkeyid";
00231         jVars_types[jVarGPGKeyID] = jTypeString;
00232 #endif /* USE_GPGME */
00233 
00234         if (*jVars_defaults_handler) {
00235                 jVars_defaults_handler();
00236         }
00237         jVars_read_defaults();
00238 
00239         return 1;
00240 }

int jVars_inset_personal_var char *  var  ) 
 

char* jVars_itos jVar  jvar  ) 
 

Definition at line 398 of file JVariables.c.

References jVars_strings.

00400 {
00401         return jVars_strings[jvar];
00402 }

void jVars_read_defaults  ) 
 

Definition at line 483 of file JVariables.c.

References dprintf(), dVars, jVars_read_conf(), varfiledefaults, varfilefixed, and varfilepersonal.

Referenced by jVars_init().

00484 {
00485         dprintf(dVars, "Reading defaults\n");
00486         jVars_read_conf(varfilefixed, 1);
00487         jVars_read_conf(varfiledefaults, 0);
00488         if (varfilepersonal) {
00489                 jVars_read_conf(varfilepersonal, 0);
00490         }
00491 }

int jVars_set jVar  name,
void *  setting
 

Definition at line 333 of file JVariables.c.

References jVars_contents, jVars_fixed, jVars_set_error(), and jVars_types.

Referenced by jVars_read_conf(), jwg_on_event_handler(), jwg_set_defaults_handler(), jwgc_change_resource_event_handler(), and main().

00336 {
00337         void *oldsetting;
00338 
00339         if (name < 0 || name >= jNumVars) {
00340                 jVars_set_error("Variable does not exist.");
00341                 return 0;
00342         }
00343 
00344         if (!setting) {
00345                 jVars_set_error("No setting specified.");
00346                 return 0;
00347         }
00348 
00349         if (*jVars_check_handler[name]) {
00350                 if (!(jVars_check_handler[name] (setting))) {
00351                         /* handler is expected to set error */
00352                         return 0;
00353                 }
00354         }
00355 
00356         if (jVars_fixed[name]) {
00357                 jVars_set_error("The variable you've selected can not be changed.");
00358                 return 0;
00359         }
00360         else {
00361                 oldsetting = jVars_contents[name];
00362                 if (jVars_types[name] == jTypeString) {
00363                         jVars_contents[name] = strdup(setting);
00364                 }
00365                 else if (jVars_types[name] == jTypeNumber) {
00366                         int *intset;
00367                         intset = (int *)malloc(sizeof(int));
00368                         *intset = atoi(setting);
00369                         jVars_contents[name] = intset;
00370                 }
00371                 else if (jVars_types[name] == jTypeBool) {
00372                         int *intset;
00373                         intset = (int *)malloc(sizeof(int));
00374                         *intset = 0;
00375                         if (!strcmp(setting, "on")
00376                                         || !strcmp(setting, "enable")
00377                                         || !strcmp(setting, "enabled")
00378                                         || !strcmp(setting, "true")
00379                                         || !strcmp(setting, "1")) {
00380                                 *intset = 1;
00381                         }
00382                         jVars_contents[name] = intset;
00383                 }
00384 
00385                 if (*jVars_change_handler[name]) {
00386                         jVars_change_handler[name] (oldsetting, jVars_contents[name]);
00387                 }
00388 
00389                 if (oldsetting != NULL) {
00390                         free(oldsetting);
00391                 }
00392         }
00393 
00394         return 1;
00395 }

void jVars_set_change_handler jVar  jvar,
void(*)()  handler
 

Definition at line 262 of file JVariables.c.

Referenced by setup_jwgc_variable_handlers().

00265 {
00266         jVars_change_handler[jvar] = handler;
00267 }

void jVars_set_check_handler jVar  jvar,
int(*)()  handler
 

Definition at line 270 of file JVariables.c.

Referenced by setup_jwgc_variable_handlers().

00273 {
00274         jVars_check_handler[jvar] = handler;
00275 }

void jVars_set_defaults_handler void(*)()  handler  ) 
 

Definition at line 286 of file JVariables.c.

Referenced by main().

00288 {
00289         jVars_defaults_handler = handler;
00290 }

void jVars_set_error char *  errstr  ) 
 

Definition at line 243 of file JVariables.c.

References varerrorstr.

00245 {
00246         if (varerrorstr) { free(varerrorstr); }
00247         varerrorstr = strdup(errorstr);
00248 }

int jVars_set_personal_var char *  var,
char *  value
 

Definition at line 65 of file JVariables.c.

References varfilepersonal.

00068 {
00069         int written;
00070         FILE *fpin, *fpout;
00071         char *varfilebackup, varbfr[512];
00072 
00073         written = 0;
00074 
00075         if (!varfilepersonal)
00076                 return 0;
00077 
00078         varfilebackup = (char *)malloc(sizeof(char) *
00079                         (strlen(varfilepersonal) + 7 + 1));
00080         strcpy(varfilebackup, varfilepersonal);
00081         strcat(varfilebackup, ".backup");
00082 
00083         if (!(fpout = fopen(varfilebackup, "w")))
00084                 return 0;
00085 
00086         if ((fpin = fopen(varfilepersonal, "r")) != NULL) {
00087                 while (fgets(varbfr, sizeof varbfr, fpin) != (char *) 0) {
00088                         varbfr[511] = '\0';
00089 
00090                         if (varline(varbfr, var)) {
00091                                 fprintf(fpout, "%s = %s\n", var, value);
00092                                 written = 1;
00093                         }
00094                         else
00095                                 fprintf(fpout, "%s\n", varbfr);
00096                 }
00097                 fclose(fpin);
00098         }
00099 
00100         if (!written)
00101                 fprintf(fpout, "%s = %s\n", var, value);
00102 
00103         if (fclose(fpout) == EOF)
00104                 return 0;
00105 
00106         if (rename(varfilebackup, varfilepersonal))
00107                 return 0;
00108 
00109         return 1;
00110 }

void jVars_set_show_handler jVar  jvar,
int(*)()  handler
 

Definition at line 278 of file JVariables.c.

Referenced by setup_jwgc_variable_handlers().

00281 {
00282         jVars_show_handler[jvar] = handler;
00283 }

char* jVars_show jVar  name  ) 
 

Definition at line 309 of file JVariables.c.

References jNumVars, jVars_contents, and jVars_set_error().

Referenced by jwg_on_event_handler().

00311 {
00312         if (name >= jNumVars || name < 0) {
00313                 jVars_set_error("Variable unknown.");
00314                 return NULL;
00315         }
00316 
00317         if (*jVars_show_handler[name]) {
00318                 if (!(jVars_show_handler[name] ())) {
00319                         /* handler is expected to set error */
00320                         return NULL;
00321                 }
00322         }
00323 
00324         if (jVars_contents[name]) {
00325                 return jVars_contents[name];
00326         }
00327         else {
00328                 return (char *)"<not set>";
00329         }
00330 }

jVar jVars_stoi char *  jvar  ) 
 

Definition at line 405 of file JVariables.c.

References jVar, and jVars_strings.

Referenced by eval_expr(), jVars_read_conf(), and jwg_on_event_handler().

00407 {
00408         jVar i;
00409 
00410         for (i = 0; i < jNumVars; i++) {
00411                 if (!strcmp(jvar, jVars_strings[i])) {
00412                         return i;
00413                 }
00414         }
00415 
00416         return -1;
00417 }

void jwg_delete jwgconn  j  ) 
 

Definition at line 97 of file JXMLComm.c.

References jwg_stop(), jwgconn, jwgconn_struct::p, and xode_pool_free().

00098 {
00099         if (!jwg)
00100                 return;
00101 
00102         jwg_stop(jwg);
00103         xode_pool_free(jwg->p);
00104 }

int jwg_getfd jwgconn  j  ) 
 

Definition at line 243 of file JXMLComm.c.

References jwgconn_struct::fd, and jwgconn.

Referenced by check_live_jwgc(), jctl_do_sendrecv(), jwgc_init(), and main().

00244 {
00245         if (jwg) {
00246                 return jwg->fd;
00247         }
00248         else {
00249                 return -1;
00250         }
00251 }

jwgconn jwg_new  ) 
 

Definition at line 40 of file JXMLComm.c.

References jwgconn_struct::fd, jwgconn, jwgconn_struct::p, jwgconn_struct::sckfd, jwgconn_struct::state, xode_pool, xode_pool_mallocx(), and xode_pool_new().

Referenced by check_live_jwgc(), jctl_do_sendrecv(), and main().

00041 {
00042         xode_pool p;
00043         jwgconn jwg;
00044 
00045         p = xode_pool_new();
00046         if (!p)
00047                 return (NULL);
00048         jwg = xode_pool_mallocx(p, sizeof(jwgconn_struct), 0);
00049         if (!jwg)
00050                 return (NULL);
00051         jwg->p = p;
00052 
00053         jwg->state = JWGCONN_STATE_OFF;
00054         jwg->fd = -1;
00055         jwg->sckfd = -1;
00056 
00057         return jwg;
00058 }

void jwg_packet_handler jwgconn  j,
jwgconn_packet_h  h
 

void jwg_poll jwgconn  j,
int  timeout
 

Definition at line 674 of file JXMLComm.c.

References jwgconn_struct::fd, jwg_recv(), jwg_sockselect(), jwgconn, NULL, and jwgconn_struct::state.

Referenced by check_live_jwgc(), jctl_do_sendrecv(), and main().

00675 {
00676         fd_set fds;
00677         FILE *selfd;
00678         struct timeval tv;
00679 
00680         if (!jwg || jwg->state == JWGCONN_STATE_OFF)
00681                 return;
00682 
00683         FD_ZERO(&fds);
00684         FD_SET(jwg->fd, &fds);
00685         selfd = (FILE *) jwg->fd;
00686 
00687         if (timeout < 0) {
00688                 if (jwg_sockselect((int) selfd + 1, &fds, NULL, NULL, NULL) > 0)
00689                         jwg_recv(jwg);
00690         }
00691         else {
00692                 tv.tv_sec = 0;
00693                 tv.tv_usec = timeout;
00694 
00695                 if (jwg_sockselect((int) selfd + 1, &fds, NULL, NULL, &tv) > 0)
00696                         jwg_recv(jwg);
00697         }
00698 }

void jwg_recv jwgconn  j  ) 
 

Definition at line 529 of file JXMLComm.c.

References dJWG, dParser, dprintf(), errno, jwgconn_struct::fd, jwg_sockrecv(), jwg_sockselect(), jwgconn, NULL, jwgconn_struct::parser, jwgconn_struct::state, XML_ErrorString(), XML_GetCurrentByteIndex(), XML_GetCurrentColumnNumber(), XML_GetCurrentLineNumber(), XML_GetErrorCode(), and XML_Parse().

Referenced by jwg_poll().

00530 {
00531         char *fullbuf;
00532         static char buf[4096];
00533         int len, totallen, fromlen, errcode;
00534         struct sockaddr_in from;
00535         fd_set fds;
00536         FILE *selfd;
00537         struct timeval tv;
00538 
00539         if (!jwg || jwg->state == JWGCONN_STATE_OFF)
00540                 return;
00541 
00542         fullbuf = (char *) malloc(sizeof(char));
00543         fullbuf[0] = '\0';
00544         totallen = 0;
00545 
00546         FD_ZERO(&fds);
00547         FD_SET(jwg->fd, &fds);
00548         selfd = (FILE *) jwg->fd;
00549         tv.tv_sec = 0;
00550         tv.tv_usec = 100000;
00551 
00552         while (jwg_sockselect((int) selfd + 1, &fds, NULL, NULL, &tv) > 0) {
00553                 len = jwg_sockrecv(jwg->fd, buf, sizeof(buf) - 1);
00554                 if (len <= 0) {
00555                         break;
00556                 }
00557                 dprintf(dJWG, " in piece[%d]: %s\n", len, buf);
00558                 fullbuf = (char *) realloc(fullbuf, strlen(fullbuf) + strlen(buf) + 1);
00559                 strcat(fullbuf, buf);
00560                 totallen += len;
00561         }
00562 /*
00563         while ((len = jwg_sockrecv(jwg->fd, buf, sizeof(buf) - 1)) > 0) {
00564                 dprintf(dJWG, " in piece[%d]: %s\n", len, buf);
00565                 fullbuf = (char *) realloc(fullbuf, strlen(fullbuf) + strlen(buf) + 1);
00566                 strcat(fullbuf, buf);
00567                 totallen += len;
00568         }
00569 */
00570 
00571         if (totallen > 0) {
00572                 dprintf(dJWG, " in[%d]: %s\n", totallen, fullbuf);
00573                 errcode = XML_Parse(jwg->parser, fullbuf, totallen - 1, 0);
00574                 dprintf(dParser, "parser index %d, line %d, col %d\n", XML_GetCurrentByteIndex(jwg->parser), XML_GetCurrentLineNumber(jwg->parser), XML_GetCurrentColumnNumber(jwg->parser));
00575                 if (errcode == 0) {
00576                         dprintf(dParser, "parser error %d at byte %d: %s\n", XML_GetErrorCode(jwg->parser), XML_GetCurrentByteIndex(jwg->parser), XML_ErrorString(XML_GetErrorCode(jwg->parser)));
00577                 }
00578                 else {
00579                         dprintf(dParser, "parser complete\n");
00580                 }
00581         }
00582         else {
00583                 dprintf(dJWG, "jwg_recv: read failed, %d:%d:%s\n", totallen, errno, strerror(errno));
00584         }
00585 
00586         free(fullbuf);
00587 }

void jwg_send jwgconn  j,
xode  x
 

Definition at line 261 of file JXMLComm.c.

References dJWG, dprintf(), errno, jwgconn_struct::fd, jwg_sockselect(), jwg_socksend(), jwgconn, NULL, jwgconn_struct::state, xode, and xode_to_str().

Referenced by check_live_jwgc(), jctl_do_sendrecv(), and main().

00262 {
00263         char *buf = xode_to_str(x);
00264         fd_set fds;
00265         FILE *selfd;
00266         struct timeval tv;
00267         int numwrote, totalsize, len, ret;
00268 
00269         if (!jwg || jwg->state == JWGCONN_STATE_OFF)
00270                 return;
00271 
00272         if (!buf)
00273                 return;
00274 
00275         FD_ZERO(&fds);
00276         FD_SET(jwg->fd, &fds);
00277         selfd = (FILE *) jwg->fd;
00278         tv.tv_sec = 0;
00279         tv.tv_usec = 100000;
00280 
00281         ret = jwg_sockselect((int) selfd + 1, NULL, &fds, NULL, &tv);
00282         if (ret < 0) {
00283                 dprintf(dJWG, "Error on select: %s\n", strerror(errno));
00284                 return;
00285         }
00286         else if (ret == 0) {
00287                 dprintf(dJWG, "Time expired while waiting to write.\n");
00288                 return;
00289         }
00290 
00291         totalsize = strlen(buf) + 1;
00292         numwrote = 0;
00293         while (numwrote < totalsize) {
00294 /*
00295                 len = send(jwg->fd, buf, totalsize - numwrote, 0);
00296 */
00297                 len = jwg_socksend(jwg->fd, buf, totalsize - numwrote);
00298                 if (len < 0) {
00299                         dprintf(dJWG, "Error writing to socket: %s\n", strerror(errno));
00300                         break;
00301                 }
00302                 numwrote += len;
00303                 dprintf(dJWG, "sent %d bytes, %d wrote out of %d\n", len, numwrote, totalsize);
00304                 buf += len;
00305         }
00306         dprintf(dJWG, "out[%d]: %s\n", totalsize, buf);
00307 }

void jwg_send_raw jwgconn  j,
const char *  str
 

Definition at line 409 of file JXMLComm.c.

References dJWG, dprintf(), jwgconn_struct::fd, jwgconn, and jwgconn_struct::state.

00410 {
00411         if (jwg && jwg->state != JWGCONN_STATE_OFF)
00412                 write(jwg->fd, str, strlen(str));
00413         dprintf(dJWG, "out: %s\n", str);
00414 }

jwgconn jwg_server  ) 
 

Definition at line 69 of file JXMLComm.c.

References jwgconn_struct::fd, jwgconn, jwgconn_struct::p, jwgconn_struct::sckfd, jwgconn_struct::state, xode_pool, xode_pool_mallocx(), and xode_pool_new().

Referenced by jwgc_init().

00070 {
00071         xode_pool p;
00072         jwgconn jwg;
00073 
00074         p = xode_pool_new();
00075         if (!p)
00076                 return (NULL);
00077         jwg = xode_pool_mallocx(p, sizeof(jwgconn_struct), 0);
00078         if (!jwg)
00079                 return (NULL);
00080         jwg->p = p;
00081 
00082         jwg->state = JWGCONN_STATE_OFF;
00083         jwg->fd = -1;
00084         jwg->sckfd = -1;
00085 
00086         return jwg;
00087 }

void jwg_serverror jwgconn  jwg,
char *  text
 

Definition at line 373 of file JXMLComm.c.

References jwg_servsend(), jwgconn, xode, xode_free(), xode_insert_cdata(), and xode_new().

Referenced by jwg_on_event_handler().

00374 {
00375         xode out;
00376 
00377         out = xode_new("error");
00378         xode_insert_cdata(out, text, strlen(text));
00379         jwg_servsend(jwg, out);
00380         xode_free(out);
00381 }

void jwg_servpoll jwgconn  j,
int  timeout
 

Definition at line 708 of file JXMLComm.c.

References jwgconn_struct::fd, jwg_servrecv(), jwg_sockselect(), jwgconn, NULL, and jwgconn_struct::state.

00709 {
00710         fd_set fds;
00711         FILE *selfd;
00712         struct timeval tv;
00713 
00714         if (!jwg || jwg->state == JWGCONN_STATE_OFF)
00715                 return;
00716 
00717         FD_ZERO(&fds);
00718         FD_SET(jwg->fd, &fds);
00719         selfd = (FILE *) jwg->fd;
00720 
00721 
00722         if (timeout < 0) {
00723                 if (select((int) selfd + 1, &fds, NULL, NULL, NULL) > 0)
00724                         jwg_servrecv(jwg);
00725         }
00726         else {
00727                 tv.tv_sec = 0;
00728                 tv.tv_usec = timeout;
00729 
00730                 if (jwg_sockselect((int) selfd + 1, &fds, NULL, NULL, &tv) > 0)
00731                         jwg_servrecv(jwg);
00732         }
00733 }

void jwg_servrecv jwgconn  j  ) 
 

Definition at line 596 of file JXMLComm.c.

References dJWG, dParser, dprintf(), errno, jwgconn_struct::fd, jwg_reset(), jwg_sockrecv(), jwg_sockselect(), jwgconn, NULL, jwgconn_struct::parser, jwgconn_struct::sckfd, jwgconn_struct::state, XML_ErrorString(), XML_GetCurrentByteIndex(), XML_GetCurrentColumnNumber(), XML_GetCurrentLineNumber(), XML_GetErrorCode(), and XML_Parse().

Referenced by jwg_servpoll(), and jwgc_init().

00597 {
00598         char *fullbuf;
00599         static char buf[4096];
00600         int len, totallen, fromlen, errcode;
00601         struct sockaddr_in from;
00602         fd_set fds;
00603         FILE *selfd;
00604         struct timeval tv;
00605         struct linger li;
00606 
00607         li.l_onoff = 1;
00608         li.l_linger = 900;
00609 
00610         if (!jwg || jwg->state == JWGCONN_STATE_OFF)
00611                 return;
00612 
00613         fullbuf = (char *) malloc(sizeof(char));
00614         fullbuf[0] = '\0';
00615         totallen = 0;
00616 
00617         fromlen = sizeof(from);
00618         jwg->sckfd = accept(jwg->fd, (struct sockaddr *) & from, &fromlen);
00619         if (jwg->sckfd < 0) {
00620                 dprintf(dJWG, "jwg_recv: accept failed, %d:%s\n", errno, strerror(errno));
00621                 return;
00622         }
00623 
00624         if (setsockopt(jwg->sckfd, SOL_SOCKET, SO_LINGER, (char *)&li,
00625                         sizeof(li)) == -1) {
00626                 dprintf(dJWG, "jwg_recv: set linger failed, %d:%s\n", errno, strerror(errno));
00627                 return;
00628         }
00629 
00630         FD_ZERO(&fds);
00631         FD_SET(jwg->sckfd, &fds);
00632         selfd = (FILE *) jwg->sckfd;
00633         tv.tv_sec = 0;
00634         tv.tv_usec = 100000;
00635 
00636         while (jwg_sockselect((int) selfd + 1, &fds, NULL, NULL, &tv) > 0) {
00637                 len = jwg_sockrecv(jwg->sckfd, buf, sizeof(buf) - 1);
00638                 if (len <= 0) {
00639                         break;
00640                 }
00641                 dprintf(dJWG, " in piece[%d]: %s\n", len, buf);
00642                 fullbuf = (char *) realloc(fullbuf, strlen(fullbuf) + strlen(buf) + 1);
00643                 strcat(fullbuf, buf);
00644                 totallen += len;
00645         }
00646 
00647         if (totallen > 0) {
00648                 dprintf(dJWG, " in[%d]: %s\n", totallen, fullbuf);
00649                 errcode = XML_Parse(jwg->parser, fullbuf, totallen - 1, 0);
00650                 dprintf(dParser, "parser index %d, line %d, col %d\n", XML_GetCurrentByteIndex(jwg->parser), XML_GetCurrentLineNumber(jwg->parser), XML_GetCurrentColumnNumber(jwg->parser));
00651                 if (errcode == 0) {
00652                         dprintf(dParser, "parser error %d at byte %d: %s\n", XML_GetErrorCode(jwg->parser), XML_GetCurrentByteIndex(jwg->parser), XML_ErrorString(XML_GetErrorCode(jwg->parser)));
00653                 }
00654                 else {
00655                         dprintf(dParser, "parser complete\n");
00656                 }
00657                 jwg_reset(jwg);
00658         }
00659         else {
00660                 dprintf(dJWG, "jwg_servrecv: read failed, %d:%d:%s\n", totallen, errno, strerror(errno));
00661         }
00662 
00663         free(fullbuf);
00664 }

void jwg_servsend jwgconn  j,
xode  x
 

Definition at line 317 of file JXMLComm.c.

References dJWG, dprintf(), errno, jwg_sockselect(), jwg_socksend(), jwgconn, NULL, jwgconn_struct::sckfd, jwgconn_struct::state, xode, and xode_to_str().

Referenced by jwg_on_event_handler(), jwg_serverror(), jwg_servsuccess(), list_contacts(), list_contacts_bygroup(), and show_status().

00318 {
00319         char *buf = xode_to_str(x);
00320         int numwrote, totalsize, len, ret;
00321         FILE *selfd;
00322         struct timeval tv;
00323         fd_set fds;
00324 
00325         if (!jwg || jwg->state == JWGCONN_STATE_OFF)
00326                 return;
00327 
00328         if (!buf)
00329                 return;
00330 
00331         FD_ZERO(&fds);
00332         FD_SET(jwg->sckfd, &fds);
00333         selfd = (FILE *) jwg->sckfd;
00334         tv.tv_sec = 0;
00335         tv.tv_usec = 100000;
00336 
00337         ret = jwg_sockselect((int) selfd + 1, NULL, &fds, NULL, &tv);
00338         if (ret < 0) {
00339                 dprintf(dJWG, "Error on select: %s\n", strerror(errno));
00340                 return;
00341         }
00342         else if (ret == 0) {
00343                 dprintf(dJWG, "Time expired while waiting to write.\n");
00344                 return;
00345         }
00346 
00347         totalsize = strlen(buf) + 1;
00348         numwrote = 0;
00349         dprintf(dJWG, "out[%d]: %s\n", totalsize, buf);
00350         while (numwrote < totalsize) {
00351 /*
00352                 len = send(jwg->sckfd, buf, totalsize - numwrote, 0);
00353 */
00354                 len = jwg_socksend(jwg->sckfd, buf, totalsize - numwrote);
00355                 if (len < 0) {
00356                         dprintf(dJWG, "Error writing to socket: %s\n", strerror(errno));
00357                         break;
00358                 }
00359                 numwrote += len;
00360                 dprintf(dJWG, "sent %d bytes, %d wrote out of %d\n", len, numwrote, totalsize);
00361                 buf += len;
00362         }
00363 }

void jwg_servsend_raw jwgconn  j,
const char *  str
 

Definition at line 424 of file JXMLComm.c.

References dJWG, dprintf(), jwgconn, jwgconn_struct::sckfd, and jwgconn_struct::state.

00425 {
00426         if (jwg && jwg->state != JWGCONN_STATE_OFF)
00427                 write(jwg->sckfd, str, strlen(str));
00428         dprintf(dJWG, "out: %s\n", str);
00429 }

void jwg_servsuccess jwgconn  jwg,
char *  text
 

Definition at line 391 of file JXMLComm.c.

References jwg_servsend(), jwgconn, xode, xode_free(), xode_insert_cdata(), and xode_new().

Referenced by jwg_on_event_handler().

00392 {
00393         xode out;
00394 
00395         out = xode_new("success");
00396         xode_insert_cdata(out, text, strlen(text));
00397         jwg_servsend(jwg, out);
00398         xode_free(out);
00399 }

void jwg_start jwgconn  j  ) 
 

Definition at line 143 of file JXMLComm.c.

References jwgconn_struct::fd, JConnect(), jwgconn, NULL, jwgconn_struct::parser, jwgconn_struct::state, XML_ParserCreate(), XML_SetCharacterDataHandler(), XML_SetElementHandler(), XML_SetUserData(), and xode.

Referenced by check_live_jwgc(), jctl_do_sendrecv(), and main().

00144 {
00145         xode x;
00146         char *t, *t2;
00147         int len, fromlen, errcode;
00148         struct sockaddr_in from;
00149 
00150         if (!jwg || jwg->state != JWGCONN_STATE_OFF)
00151                 return;
00152 
00153         jwg->parser = XML_ParserCreate(NULL);
00154         XML_SetUserData(jwg->parser, (void *) jwg);
00155         XML_SetElementHandler(jwg->parser, jwg_startElement, jwg_endElement);
00156         XML_SetCharacterDataHandler(jwg->parser, jwg_charData);
00157 
00158         jwg->fd = JConnect();
00159         if (jwg->fd < 0) {
00160                 return;
00161         }
00162         jwg->state = JWGCONN_STATE_CONNECTED;
00163 }

void jwg_stop jwgconn  j  ) 
 

Definition at line 221 of file JXMLComm.c.

References jwgconn_struct::fd, jwgconn, jwgconn_struct::parser, jwgconn_struct::sckfd, jwgconn_struct::state, and XML_ParserFree().

Referenced by check_live_jwgc(), jabber_finalize(), jctl_do_sendrecv(), jwg_delete(), and main().

00222 {
00223         if (!jwg || jwg->state == JWGCONN_STATE_OFF)
00224                 return;
00225 
00226         jwg->state = JWGCONN_STATE_OFF;
00227         close(jwg->fd);
00228         jwg->fd = -1;
00229         jwg->sckfd = -1;
00230         XML_ParserFree(jwg->parser);
00231 }

jwgpacket jwgpacket_new xode  x  ) 
 

Definition at line 736 of file JXMLComm.c.

References _jwgpacket, jwgpacket, jwgpacket_reset(), jwgpacket_struct::x, xode, xode_get_pool(), and xode_pool_malloc().

00737 {
00738         jwgpacket p;
00739 
00740         if (x == NULL)
00741                 return NULL;
00742 
00743         p = xode_pool_malloc(xode_get_pool(x), sizeof(_jwgpacket));
00744         p->x = x;
00745 
00746         return jwgpacket_reset(p);
00747 }

jwgpacket jwgpacket_reset jwgpacket  p  ) 
 

Definition at line 750 of file JXMLComm.c.

References _jwgpacket, jwgpacket, jwgpacket_struct::p, jwgpacket_struct::type, jwgpacket_struct::x, xode, xode_get_name(), and xode_get_pool().

Referenced by jwg_on_event_handler(), and jwgpacket_new().

00751 {
00752         xode x;
00753 
00754         x = p->x;
00755         memset(p, 0, sizeof(_jwgpacket));
00756         p->x = x;
00757         p->p = xode_get_pool(x);
00758 
00759         if (strncmp(xode_get_name(x), "message", 7) == 0) {
00760                 p->type = JWGPACKET_MESSAGE;
00761         }
00762         else if (strncmp(xode_get_name(x), "locate", 6) == 0) {
00763                 p->type = JWGPACKET_LOCATE;
00764         }
00765         else if (strncmp(xode_get_name(x), "status", 6) == 0) {
00766                 p->type = JWGPACKET_STATUS;
00767         }
00768         else if (strncmp(xode_get_name(x), "shutdown", 8) == 0) {
00769                 p->type = JWGPACKET_SHUTDOWN;
00770         }
00771         else if (strncmp(xode_get_name(x), "check", 5) == 0) {
00772                 p->type = JWGPACKET_CHECK;
00773         }
00774         else if (strncmp(xode_get_name(x), "reread", 6) == 0) {
00775                 p->type = JWGPACKET_REREAD;
00776         }
00777         else if (strncmp(xode_get_name(x), "showvar", 7) == 0) {
00778                 p->type = JWGPACKET_SHOWVAR;
00779         }
00780         else if (strncmp(xode_get_name(x), "subscribe", 9) == 0) {
00781                 p->type = JWGPACKET_SUBSCRIBE;
00782         }
00783         else if (strncmp(xode_get_name(x), "unsubscribe", 11) == 0) {
00784                 p->type = JWGPACKET_UNSUBSCRIBE;
00785         }
00786         else if (strncmp(xode_get_name(x), "nickname", 8) == 0) {
00787                 p->type = JWGPACKET_NICKNAME;
00788         }
00789         else if (strncmp(xode_get_name(x), "group", 5) == 0) {
00790                 p->type = JWGPACKET_GROUP;
00791         }
00792         else if (strncmp(xode_get_name(x), "register", 8) == 0) {
00793                 p->type = JWGPACKET_REGISTER;
00794         }
00795         else if (strncmp(xode_get_name(x), "search", 6) == 0) {
00796                 p->type = JWGPACKET_SEARCH;
00797         }
00798         else if (strncmp(xode_get_name(x), "setvar", 6) == 0) {
00799                 p->type = JWGPACKET_SETVAR;
00800         }
00801         else if (strncmp(xode_get_name(x), "join", 4) == 0) {
00802                 p->type = JWGPACKET_JOIN;
00803         }
00804         else if (strncmp(xode_get_name(x), "leave", 5) == 0) {
00805                 p->type = JWGPACKET_LEAVE;
00806         }
00807         else if (strncmp(xode_get_name(x), "debug", 5) == 0) {
00808                 p->type = JWGPACKET_DEBUG;
00809         }
00810         else if (strncmp(xode_get_name(x), "ping", 4) == 0) {
00811                 p->type = JWGPACKET_PING;
00812         }
00813         else {
00814                 p->type = JWGPACKET_UNKNOWN;
00815         }
00816 
00817         return p;
00818 }

void list_agents xode  x  ) 
 

Definition at line 420 of file JContact.c.

References agent_list, xode, xode_dup(), xode_insert_node(), and xode_insert_tag().

Referenced by show_status().

00421 {
00422         int i;
00423         xode y, z;
00424 
00425         y = xode_insert_tag(x, "agents");
00426         for (i = 0; i < num_agents; i++) {
00427                 z = xode_dup(agent_list[i]);
00428                 xode_insert_node(y, z);
00429         }
00430 }

void list_contacts jwgconn  jwg,
char *  matchstr,
int  strictmatch,
int  skipnotavail
 

Definition at line 238 of file JContact.c.

References contact_list, dprintf(), dXML, jwg_servsend(), jwgconn, test_match(), xode, xode_dup(), xode_free(), xode_get_attrib(), xode_get_firstchild(), xode_get_nextsibling(), xode_get_tag(), xode_has_children(), xode_hide(), xode_insert_node(), xode_new(), and xode_to_prettystr().

Referenced by jwg_on_event_handler().

00243 {
00244         int i, k;
00245         xode x, y, ny, z, r, nr;
00246 
00247         x = xode_new("contacts");
00248         for (i = 0; i < num_contacts; i++) {
00249                 y = xode_dup(contact_list[i]);
00250                 xode_insert_node(x, y);
00251         }
00252 
00253         if (matchstr) {
00254                 ny = y = xode_get_firstchild(x);
00255                 while (ny) {
00256                         ny = xode_get_nextsibling(ny);
00257                         if (!test_match(matchstr, y, strictmatch)) {
00258                                 dprintf(dXML, "HIDE-A:\n%s\n",
00259                                         xode_to_prettystr(y));
00260                                 xode_hide(y);
00261                         }
00262                         y = ny;
00263                 }
00264         }
00265 
00266         if (skipnotavail) {
00267                 ny = y = xode_get_firstchild(x);
00268                 while (ny) {
00269                         z = xode_get_tag(y, "resources");
00270                         nr = r = xode_get_firstchild(z);
00271                         while (nr) {
00272                                 char *curstatus;
00273                                 nr = xode_get_nextsibling(nr);
00274                                 curstatus = xode_get_attrib(r, "status");
00275                                 if (!curstatus || !strcmp(curstatus,
00276                                                 "unavailable")) {
00277                                         dprintf(dXML, "HIDE-B:\n%s\n",
00278                                                 xode_to_prettystr(r));
00279                                         xode_hide(r);
00280                                 }
00281                                 r = nr;
00282                         }
00283                         ny = xode_get_nextsibling(ny);
00284                         if (!xode_has_children(z)) {
00285                                 dprintf(dXML, "HIDE-C:\n%s\n",
00286                                         xode_to_prettystr(y));
00287                                 xode_hide(y);
00288                         }
00289                         y = ny;
00290                 }
00291         }
00292 
00293         jwg_servsend(jwg, x);
00294         xode_free(x);
00295 }

void list_contacts_bygroup jwgconn  jwg,
char *  matchstr,
int  strictmatch,
int  skipnotavail
 

Definition at line 322 of file JContact.c.

References contact_list, dprintf(), dXML, find_contact_group(), jwg_servsend(), jwgconn, test_match(), xode, xode_dup(), xode_free(), xode_get_attrib(), xode_get_firstchild(), xode_get_nextsibling(), xode_get_tag(), xode_has_children(), xode_hide(), xode_hide_attrib(), xode_insert_node(), xode_insert_tag(), xode_new(), xode_put_attrib(), and xode_to_prettystr().

Referenced by jwg_on_event_handler().

00327 {
00328         int i, k;
00329         xode x, y, ny, z, r, nr, g, ng;
00330         char *group;
00331 
00332         x = xode_new("contacts");
00333         for (i = 0; i < num_contacts; i++) {
00334                 y = xode_dup(contact_list[i]);
00335                 group = xode_get_attrib(y, "group");
00336                 if (!group) {
00337                         group = "Unknown";
00338                 }
00339                 z = find_contact_group(x, group);
00340                 if (!z) {
00341                         z = xode_insert_tag(x, "group");
00342                         xode_put_attrib(z, "name", group);
00343                 }
00344                 xode_hide_attrib(y, "group");
00345                 xode_insert_node(z, y);
00346         }
00347 
00348         if (matchstr) {
00349                 ng = g = xode_get_firstchild(x);
00350                 while (ng) {
00351                         ny = y = xode_get_firstchild(g);
00352                         while (ny) {
00353                                 ny = xode_get_nextsibling(y);
00354                                 if (!test_match(matchstr, y, strictmatch)) {
00355                                         dprintf(dXML,
00356                                                 "HIDE-D:\n%s\n",
00357                                                 xode_to_prettystr(y));
00358                                         xode_hide(y);
00359                                 }
00360                                 y = ny;
00361                         }
00362 
00363                         ng = xode_get_nextsibling(ng);
00364                         if (!xode_has_children(g)) {
00365                                 dprintf(dXML, "HIDE-E:\n%s\n",
00366                                         xode_to_prettystr(g));
00367                                 xode_hide(g);
00368                         }
00369                         g = ng;
00370                 }
00371         }
00372 
00373         if (skipnotavail) {
00374                 ng = g = xode_get_firstchild(x);
00375                 while (ng) {
00376                         ny = y = xode_get_firstchild(g);
00377                         while (ny) {
00378                                 z = xode_get_tag(y, "resources");
00379                                 nr = r = xode_get_firstchild(z);
00380                                 while (nr) {
00381                                         char *curstatus;
00382                                         nr = xode_get_nextsibling(nr);
00383                                         curstatus = xode_get_attrib(r,
00384                                                                 "status");
00385                                         if (!curstatus || !strcmp(curstatus,
00386                                                         "unavailable")) {
00387                                                 dprintf(dXML,
00388                                                         "HIDE-F:\n%s\n",
00389                                                         xode_to_prettystr(r));
00390                                                 xode_hide(r);
00391                                         }
00392                                         r = nr;
00393                                 }
00394 
00395                                 ny = xode_get_nextsibling(ny);
00396                                 if (!xode_has_children(z)) {
00397                                         dprintf(dXML,
00398                                                 "HIDE-G:\n%s\n",
00399                                                 xode_to_prettystr(y));
00400                                         xode_hide(y);
00401                                 }
00402                                 y = ny;
00403                         }
00404 
00405                         ng = xode_get_nextsibling(ng);
00406                         if (!xode_has_children(g)) {
00407                                 dprintf(dXML, "HIDE-H:\n%s\n",
00408                                         xode_to_prettystr(g));
00409                                 xode_hide(g);
00410                         }
00411                         g = ng;
00412                 }
00413         }
00414 
00415         jwg_servsend(jwg, x);
00416         xode_free(x);
00417 }

NAMED * lookup HASH_TABLE table,
KEY  name,
size_t  createSize
 

Definition at line 4222 of file xmlparse.c.

References XML_Memory_Handling_Suite::free_fcn, INIT_SIZE, lookup(), XML_Memory_Handling_Suite::malloc_fcn, HASH_TABLE::mem, NAMED::name, HASH_TABLE::size, HASH_TABLE::used, HASH_TABLE::usedLim, and HASH_TABLE::v.

Referenced by lookup(), and substitute().

04223 {
04224   size_t i;
04225   if (table->size == 0) {
04226     size_t tsize;
04227 
04228     if (!createSize)
04229       return 0;
04230     tsize = INIT_SIZE * sizeof(NAMED *);
04231     table->v = table->mem->malloc_fcn(tsize);
04232     if (!table->v)
04233       return 0;
04234     memset(table->v, 0, tsize);
04235     table->size = INIT_SIZE;
04236     table->usedLim = INIT_SIZE / 2;
04237     i = hash(name) & (table->size - 1);
04238   }
04239   else {
04240     unsigned long h = hash(name);
04241     for (i = h & (table->size - 1);
04242          table->v[i];
04243          i == 0 ? i = table->size - 1 : --i) {
04244       if (keyeq(name, table->v[i]->name))
04245         return table->v[i];
04246     }
04247     if (!createSize)
04248       return 0;
04249     if (table->used == table->usedLim) {
04250       /* check for overflow */
04251       size_t newSize = table->size * 2;
04252       size_t tsize = newSize * sizeof(NAMED *);
04253       NAMED **newV = table->mem->malloc_fcn(tsize);
04254       if (!newV)
04255         return 0;
04256       memset(newV, 0, tsize);
04257       for (i = 0; i < table->size; i++)
04258         if (table->v[i]) {
04259           size_t j;
04260           for (j = hash(table->v[i]->name) & (newSize - 1);
04261                newV[j];
04262                j == 0 ? j = newSize - 1 : --j)
04263             ;
04264           newV[j] = table->v[i];
04265         }
04266       table->mem->free_fcn(table->v);
04267       table->v = newV;
04268       table->size = newSize;
04269       table->usedLim = newSize/2;
04270       for (i = h & (table->size - 1);
04271            table->v[i];
04272            i == 0 ? i = table->size - 1 : --i)
04273         ;
04274     }
04275   }
04276   table->v[i] = table->mem->malloc_fcn(createSize);
04277   if (!table->v[i])
04278     return 0;
04279   memset(table->v[i], 0, createSize);
04280   table->v[i]->name = name;
04281   (table->used)++;
04282   return table->v[i];
04283 }

struct in_addr* make_addr char *  host  ) 
 

Definition at line 141 of file JNetSock.c.

References MAXHOSTNAMELEN, and NULL.

Referenced by make_netsocket().

00142 {
00143         struct hostent *hp;
00144         static struct in_addr addr;
00145         char myname[MAXHOSTNAMELEN + 1];
00146 
00147         if (host == NULL || strlen(host) == 0) {
00148                 gethostname(myname, MAXHOSTNAMELEN);
00149                 hp = gethostbyname(myname);
00150                 if (hp != NULL) {
00151                         return (struct in_addr *) * hp->h_addr_list;
00152                 }
00153         }
00154         else {
00155                 addr.s_addr = inet_addr(host);
00156                 if (addr.s_addr != -1) {
00157                         return &addr;
00158                 }
00159                 hp = gethostbyname(host);
00160                 if (hp != NULL) {
00161                         return (struct in_addr *) * hp->h_addr_list;
00162                 }
00163         }
00164         return NULL;
00165 }

int make_netsocket u_short  port,
char *  host,
int  type
 

Definition at line 63 of file JNetSock.c.

References __Xode_port, make_addr(), and NULL.

Referenced by jab_start().

00064 {
00065         int s, flag = 1;
00066         struct sockaddr_in sa;
00067         struct in_addr *saddr;
00068         int socket_type, len;
00069 
00070         /* is this a UDP socket or a TCP socket? */
00071         socket_type = (type == NETSOCKET_UDP) ? SOCK_DGRAM : SOCK_STREAM;
00072 
00073         bzero((void *) &sa, sizeof(struct sockaddr_in));
00074 
00075         if ((s = socket(AF_INET, socket_type, 0)) < 0)
00076                 return (-1);
00077         if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &flag, sizeof(flag)) < 0)
00078                 return (-1);
00079 
00080         saddr = make_addr(host);
00081         if (saddr == NULL && type != NETSOCKET_UDP)
00082                 return (-1);
00083         sa.sin_family = AF_INET;
00084         sa.sin_port = htons(port);
00085 
00086         if (type == NETSOCKET_SERVER) {
00087                 /* bind to specific address if specified */
00088                 if (host != NULL)
00089                         sa.sin_addr.s_addr = saddr->s_addr;
00090 
00091                 if (bind(s, (struct sockaddr *) & sa, sizeof sa) < 0) {
00092                         close(s);
00093                         return (-1);
00094                 }
00095 
00096                 if (!sa.sin_port) {
00097                         len = sizeof(sa);
00098                         if (getsockname(s, (struct sockaddr *) & sa, &len) < 0) {
00099                                 close(s);
00100                                 return (-1);
00101                         }
00102                 }
00103 
00104                 if (listen(s, 10) < 0) {
00105                         close(s);
00106                         return (-1);
00107                 }
00108 
00109                 __Xode_port = ntohs(sa.sin_port);
00110         }
00111         if (type == NETSOCKET_CLIENT) {
00112                 sa.sin_addr.s_addr = saddr->s_addr;
00113                 if (connect(s, (struct sockaddr *) & sa, sizeof sa) < 0) {
00114                         close(s);
00115                         return (-1);
00116                 }
00117         }
00118         if (type == NETSOCKET_UDP) {
00119                 /* bind to all addresses for now */
00120                 if (bind(s, (struct sockaddr *) & sa, sizeof sa) < 0) {
00121                         close(s);
00122                         return (-1);
00123                 }
00124 
00125                 /* if specified, use a default recipient for read/write */
00126                 if (host != NULL && saddr != NULL) {
00127                         sa.sin_addr.s_addr = saddr->s_addr;
00128                         if (connect(s, (struct sockaddr *) & sa, sizeof sa) < 0) {
00129                                 close(s);
00130                                 return (-1);
00131                         }
00132                 }
00133         }
00134 
00135 
00136         return (s);
00137 }

void remove_from_contact_list char *  contact  ) 
 

Definition at line 56 of file JContact.c.

References contact_list, dExecution, dprintf(), num_contacts, and xode_get_attrib().

Referenced by jwg_on_event_handler(), and process_iq_set().

00057 {
00058         int i;
00059         int k;
00060 
00061         for (i = 0; i < num_contacts &&
00062             (strcasecmp(contact, xode_get_attrib(contact_list[i], "jid")) != 0);
00063             i++);
00064 
00065         if (i == num_contacts) {
00066                 return;
00067         }
00068 
00069         free(contact_list[i]);
00070         for (k = i; k < (num_contacts - 1); k++) {
00071                 contact_list[k] = contact_list[k + 1];
00072         }
00073         num_contacts--;
00074 
00075         dprintf(dExecution, "Removed %s from contact list at position %d\n", contact, i);
00076 }

int set_fd_close_on_exec int  fd,
int  flag
 

Definition at line 172 of file JNetSock.c.

00173 {
00174         int oldflags = fcntl(fd, F_GETFL);
00175         int newflags;
00176 
00177         if (flag)
00178                 newflags = oldflags | FD_CLOEXEC;
00179         else
00180                 newflags = oldflags & (~FD_CLOEXEC);
00181 
00182         if (newflags == oldflags)
00183                 return 0;
00184         return fcntl(fd, F_SETFL, (long) newflags);
00185 }

void spool_add xode_spool  s,
char *  str
 

xode_spool spool_new xode_pool  p  ) 
 

char* spool_print xode_spool  s  ) 
 

Definition at line 164 of file JStr.c.

References xode_spool_node::c, xode_spool_struct::first, j_strcat(), xode_spool_struct::len, xode_spool_node::next, NULL, xode_spool_struct::p, xode_pool_malloc(), and xode_spool.

Referenced by spools().

00165 {
00166         char *ret, *tmp;
00167         struct xode_spool_node *next;
00168 
00169         if (s == NULL || s->len == 0 || s->first == NULL)
00170                 return NULL;
00171 
00172         ret = xode_pool_malloc(s->p, s->len + 1);
00173         *ret = '\0';
00174 
00175         next = s->first;
00176         tmp = ret;
00177         while (next != NULL) {
00178                 tmp = j_strcat(tmp, next->c);
00179                 next = next->next;
00180         }
00181 
00182         return ret;
00183 }

void spooler xode_spool  s,
  ...
 

char * spools xode_pool  p,
  ...
 

Definition at line 187 of file JStr.c.

References spool_print(), xode_pool, xode_spool, xode_spool_add(), and xode_spool_newfrompool().

Referenced by xode2file().

00188 {
00189         va_list ap;
00190         xode_spool s;
00191         char *arg = NULL;
00192 
00193         if (p == NULL)
00194                 return NULL;
00195 
00196         s = xode_spool_newfrompool(p);
00197 
00198         va_start(ap, p);
00199 
00200         /* loop till we hit our end flag, the first arg */
00201         while (1) {
00202                 arg = va_arg(ap, char *);
00203                 if ((xode_pool) arg == p)
00204                         break;
00205                 else
00206                         xode_spool_add(s, arg);
00207         }
00208 
00209         va_end(ap);
00210 
00211         return spool_print(s);
00212 }

void str_b64decode char *  str  ) 
 

int str_clear_unprintable const char *  in,
char **  out
 

int str_to_unicode const char *  in,
char **  out
 

int test_match char *  matchstr,
xode  contact,
int  exactmatch
 

Definition at line 499 of file JContact.c.

References exactmatch, NULL, xode, and xode_get_attrib().

Referenced by list_contacts(), and list_contacts_bygroup().

00503 {
00504         char *nick;
00505 
00506         if (!strcasecmp(xode_get_attrib(contact, "jid"), matchstr)) {
00507                 return 1;
00508         }
00509 
00510         if ((nick = xode_get_attrib(contact, "nick")) != NULL &&
00511                         !strcasecmp(nick, matchstr)) {
00512                 return 1;
00513         }
00514 
00515         if (!exactmatch && !strncasecmp(xode_get_attrib(contact, "jid"),
00516                                         matchstr, strlen(matchstr))) {
00517                 return 1;
00518         }
00519 
00520         return 0;
00521 }

void trim_message char *  str  ) 
 

Definition at line 150 of file JStr.c.

References dExecution, and dprintf().

Referenced by jab_on_packet_handler(), and jwg_on_event_handler().

00152 {
00153         int pos = strlen(str);
00154         
00155         dprintf(dExecution, "Trim start position at %d.\n", pos);
00156         while (pos >= 0 && (isspace(str[pos]) || iscntrl(str[pos]))) {
00157                 dprintf(dExecution, "Trimming position %d.\n", pos);
00158                 str[pos] = '\0';
00159                 pos--;
00160         }
00161 }

int unicode_to_str const char *  in,
char **  out
 

int update_contact_status char *  jid,
char *  status,
char *  resource
 

Definition at line 124 of file JContact.c.

References contact_list, dExecution, dprintf(), insert_into_contact_list(), insert_resource_into_contact(), jid, xode, xode_get_attrib(), xode_get_firstchild(), xode_get_nextsibling(), xode_get_tag(), xode_hide_attrib(), and xode_put_attrib().

Referenced by contact_status_change(), and process_iq_result().

00125 {
00126         int contactfound = 0;
00127         int resourcefound = 0;
00128         int i;
00129         char *pos;
00130         xode x, y;
00131         int ret = 0;
00132 
00133         dprintf(dExecution, "Updating %s/%s status to %s.\n",
00134                         jid,
00135                         resource ? resource : "NULL",
00136                         status ? status : "NULL");
00137 
00138         for (i = 0; i < num_contacts; i++) {
00139                 if (!strcasecmp(xode_get_attrib(contact_list[i], "jid"),
00140                                                         jid)) {
00141                         contactfound = 1;
00142                         if (!resource) {
00143                                 break;
00144                         }
00145                         x = xode_get_tag(contact_list[i], "resources");
00146                         y = xode_get_firstchild(x);
00147                         while (y) {
00148                                 if (!strcmp(xode_get_attrib(y, "name"),
00149                                                                 resource)) {
00150                                         char *curstatus;
00151                                         resourcefound = 1;
00152 
00153                                         curstatus = xode_get_attrib(y,
00154                                                                 "status");
00155                                         if (curstatus && !status) {
00156                                                 xode_hide_attrib(y, "status");
00157                                                 ret = 1;
00158                                         }
00159                                         else if (status && (!curstatus ||
00160                                                 strcmp(curstatus, status))) {
00161                                                 xode_put_attrib(y,
00162                                                         "status",
00163                                                         status);
00164                                                 ret = 1;
00165                                         }
00166                                         break;
00167                                 }
00168                                 y = xode_get_nextsibling(y);
00169                         }
00170 
00171                         if (!resourcefound) {
00172                                 insert_resource_into_contact(i,
00173                                                 resource, status);
00174                                 ret = 1;
00175                         }
00176 
00177                         break;
00178                 }
00179         }
00180 
00181         if (!contactfound) {
00182                 insert_into_contact_list(jid, status, resource);
00183                 ret = 1;
00184         }
00185 
00186         return ret;
00187 }

void update_group char *  target,
char *  group
 

Definition at line 447 of file JContact.c.

References contact_list, target, xode_get_attrib(), and xode_put_attrib().

Referenced by jwg_on_event_handler(), and process_iq_result().

00448 {
00449         int i;
00450 
00451         for (i = 0; i < num_contacts; i++) {
00452                 if (!strcasecmp(xode_get_attrib(contact_list[i], "jid"),
00453                                                                 target)) {
00454                         xode_put_attrib(contact_list[i], "group", group);
00455                         return;
00456                 }
00457         }
00458 }

void update_nickname char *  target,
char *  nickname
 

Definition at line 433 of file JContact.c.

References contact_list, target, xode_get_attrib(), and xode_put_attrib().

Referenced by jwg_on_event_handler(), and process_iq_result().

00434 {
00435         int i;
00436 
00437         for (i = 0; i < num_contacts; i++) {
00438                 if (!strcasecmp(xode_get_attrib(contact_list[i], "jid"),
00439                                                                 target)) {
00440                         xode_put_attrib(contact_list[i], "nick", nickname);
00441                         return;
00442                 }
00443         }
00444 }

int xode2file char *  file,
xode  node
 

Definition at line 192 of file JExpat.c.

References NULL, spools(), xode, xode_get_pool(), and xode_to_str().

00193 {
00194         char *doc, *ftmp;
00195         int fd, i;
00196 
00197         if (file == NULL || node == NULL)
00198                 return -1;
00199 
00200         ftmp = spools(xode_get_pool(node), file, ".t.m.p", xode_get_pool(node));
00201         fd = open(ftmp, O_CREAT | O_WRONLY | O_TRUNC, 0600);
00202         if (fd < 0)
00203                 return -1;
00204 
00205         doc = xode_to_str(node);
00206         i = write(fd, doc, strlen(doc));
00207         if (i < 0)
00208                 return -1;
00209 
00210         close(fd);
00211 
00212         if (rename(ftmp, file) < 0) {
00213                 unlink(ftmp);
00214                 return -1;
00215         }
00216         return 1;
00217 }

xode xode_file char *  file  ) 
 

Definition at line 121 of file JExpat.c.

References expat_charData(), expat_endElement(), expat_startElement(), NULL, XML_Parse(), XML_Parser, XML_ParserCreate(), XML_ParserFree(), XML_SetCharacterDataHandler(), XML_SetElementHandler(), XML_SetUserData(), xode, and xode_free().

00122 {
00123         XML_Parser p;
00124         xode *x, node;          /* pointer to an xode */
00125         char buf[BUFSIZ];
00126         int done, fd, len;
00127 
00128         if (NULL == file)
00129                 return NULL;
00130 
00131         fd = open(file, O_RDONLY);
00132         if (fd < 0)
00133                 return NULL;
00134 
00135         x = malloc(sizeof(void *));
00136 
00137         *x = NULL;              /* pointer to NULL */
00138         p = XML_ParserCreate(NULL);
00139         XML_SetUserData(p, x);
00140         XML_SetElementHandler(p, expat_startElement, expat_endElement);
00141         XML_SetCharacterDataHandler(p, expat_charData);
00142         do {
00143                 len = read(fd, buf, BUFSIZ);
00144                 done = len < BUFSIZ;
00145                 if (!XML_Parse(p, buf, len, done)) {
00146                         /*
00147                          * jdebug(ZONE,"xode_file_parseerror: %s",(char
00148                          * *)XML_ErrorString(XML_GetErrorCode(p)));
00149                          */
00150                         xode_free(*x);
00151                         *x = NULL;
00152                         done = 1;
00153                 }
00154         } while (!done);
00155 
00156         node = *x;
00157         XML_ParserFree(p);
00158         free(x);
00159         close(fd);
00160         return node;            /* return the xode x points to */
00161 }

void xode_put_expat_attribs xode  owner,
const char **  atts
 

Definition at line 220 of file JExpat.c.

References atts, xode, and xode_put_attrib().

Referenced by expat_startElement().

00221 {
00222         int i = 0;
00223         if (atts == NULL)
00224                 return;
00225         while (atts[i] != '\0') {
00226                 xode_put_attrib(owner, atts[i], atts[i + 1]);
00227                 i += 2;
00228         }
00229 }

xode xode_str char *  str,
int  len
 

Definition at line 91 of file JExpat.c.

References expat_charData(), expat_endElement(), expat_startElement(), NULL, XML_Parse(), XML_Parser, XML_ParserCreate(), XML_ParserFree(), XML_SetCharacterDataHandler(), XML_SetElementHandler(), XML_SetUserData(), xode, and xode_free().

00092 {
00093         XML_Parser p;
00094         xode *x, node;          /* pointer to an xode */
00095 
00096         if (NULL == str)
00097                 return NULL;
00098 
00099         x = malloc(sizeof(void *));
00100 
00101         *x = NULL;              /* pointer to NULL */
00102         p = XML_ParserCreate(NULL);
00103         XML_SetUserData(p, x);
00104         XML_SetElementHandler(p, expat_startElement, expat_endElement);
00105         XML_SetCharacterDataHandler(p, expat_charData);
00106         if (!XML_Parse(p, str, len, 1)) {
00107                 /*
00108                  * jdebug(ZONE,"xode_str_error: %s",(char
00109                  * *)XML_ErrorString(XML_GetErrorCode(p)));
00110                  */
00111                 xode_free(*x);
00112                 *x = NULL;
00113         }
00114         node = *x;
00115         free(x);
00116         XML_ParserFree(p);
00117         return node;            /* return the xode x points to */
00118 }



Last updated at Tue Dec 18 21:07:42 PST 2007. This site and project hosted by...SourceForge.net Logo

Source Perspective by Fisheye