src/socket.c

   1 /*
   2  * gaim-remote
   3  *
   4  * Copyright (C) 2002, Sean Egan <bj91704@binghamton.edu>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 /* Somewhat inspired by XMMS:
  23  *  Copyright (C) 1998-2002  Peter Alm, Mikael Alm, Olle Hallnas,
  24  *                           Thomas Nilsson and 4Front Technologies
  25  *  Copyright (C) 1999-2002  Haavard Kvaalen
  26  */
  27
  28 /* This provides code for connecting to a Gaim socket and communicating with
  29  * it.  It will eventually be made a library once the core and ui are split. */
  30
  31 #include <sys/types.h>
  32 #include <sys/socket.h>
  33 #include <sys/un.h>
  34 #include <unistd.h>
  35 #include "gaim.h"
  36 #include "gaim-socket.h"
  37
  38 void cui_send_packet (int fd, struct gaim_cui_packet *p) {
  39         int len = sizeof(p->type) + sizeof(p->subtype) + sizeof(p->length) + p->length;
  40         char *pack = g_malloc(len);
  41         char *a = pack;
  42         memcpy (a, &(p->type), sizeof(p->type));
  43         a = a + sizeof(p->type);
  44         memcpy (a, &(p->subtype), sizeof(p->subtype));
  45         a = a + sizeof(p->subtype);
  46         memcpy (a, &(p->length), sizeof(p->length));
  47         a = a + sizeof(p->length);
  48         memcpy (a, p->data, p->length);
  49         write(fd, pack, len);
  50         g_free(pack);
  51 }
  52
  53
  54 void cui_packet_append_string(struct gaim_cui_packet *p, char *str) {
  55         int len = p->length + strlen(str);
  56         char *k = g_malloc(len);
  57         memcpy(k, p->data, p->length);
  58         memcpy(k + p->length, str, strlen(str));
  59         if (p->data)
  60                 g_free(p->data);
  61         p->data = k;
  62         p->length = len;
  63 }
  64
  65 void cui_packet_append_char(struct gaim_cui_packet *p, char c) {
  66         int len = p->length + sizeof(char);
  67         char *k = g_malloc(len);
  68         memcpy(k, p->data, p->length);
  69         k[p->length] = c;
  70         if (p->data)
  71                 g_free(p->data);
  72         p->data = k;
  73         p->length = len;
  74 }
  75
  76 void cui_packet_append_raw(struct gaim_cui_packet *p, char *str, int len) {
  77         int lent = p->length + len;
  78         char *k = g_malloc(lent);
  79         memcpy(k, p->data, p->length);
  80         memcpy(k + p->length, str, len);
  81         if (p->data)
  82                 g_free(p->data);
  83         p->data = k;
  84         p->length = lent;
  85 }
  86
  87 struct gaim_cui_packet *cui_packet_new(guchar type, guchar subtype) {
  88         struct gaim_cui_packet *p = g_new0(struct gaim_cui_packet, 1);
  89         p->type = type;
  90         p->subtype = subtype;
  91         p->length = 0;
  92         p->data = NULL;
  93         return p;
  94 }
  95
  96 void cui_packet_free(struct gaim_cui_packet *p) {
  97         if (p->data)
  98                 g_free(p->data);
  99         g_free(p);
 100 }
 101
 102 struct gaim_cui_packet *cui_read_packet(int fd) {
 103         struct gaim_cui_packet *p = g_new0(struct gaim_cui_packet, 1);
 104         char *data = NULL;
 105
 106         if (!(read(fd, &p->type, sizeof(p->type)))) {
 107                 g_free(p);
 108                 return NULL;
 109         }
 110
 111
 112         if (!(read(fd, &p->subtype, sizeof(p->subtype)))) {
 113                 g_free(p);
 114                 return NULL;
 115         }
 116
 117
 118         if (!(read(fd, &p->length, sizeof(p->length)))) {
 119                 g_free(p);
 120                 return NULL;
 121         }
 122
 123         if (p->length) {
 124                 data = g_malloc(p->length);
 125                 if (!(read(fd, data, p->length))) {
 126                         g_free(p);
 127                         return NULL;
 128                 }
 129         }
 130         p->data = data;
 131         return p;
 132 }
 133
 134 /* copied directly from xmms_connect_to_session */
 135 gint gaim_connect_to_session(gint session)
 136 {
 137         gint fd;
 138         uid_t stored_uid, euid;
 139         struct sockaddr_un saddr;
 140
 141         if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) != -1)
 142         {
 143                 saddr.sun_family = AF_UNIX;
 144                 stored_uid = getuid();
 145                 euid = geteuid();
 146                 setuid(euid);
 147                 sprintf(saddr.sun_path, "%s/gaim_%s.%d", g_get_tmp_dir(), g_get_user_name(), session);
 148                 setreuid(stored_uid, euid);
 149                 if (connect(fd, (struct sockaddr *) &saddr, sizeof (saddr)) != -1)
 150                         return fd;
 151         }
 152         close(fd);
 153         return -1;
 154 }
 155
 156 gboolean gaim_session_exists(int sess)
 157 {
 158         struct gaim_cui_packet *pack = NULL;
 159
 160         int fd = gaim_connect_to_session(sess);
 161         if (fd > 0) {
 162                 pack = cui_packet_new(CUI_TYPE_META, CUI_META_PING);
 163                 cui_send_packet(fd, pack);
 164                 cui_packet_free(pack);
 165                 close(fd);
 166         } else {
 167                 return FALSE;
 168         }
 169         return TRUE;
 170 }
 171