source/lib/msrpc-agent.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 2
   4    SMB agent/socket plugin
   5    Copyright (C) Andrew Tridgell 1999
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23 #include "rpc_parse.h"
  24 #include "smb.h"
  25
  26 extern int DEBUGLEVEL;
  27
  28 static char packet[BUFFER_SIZE];
  29
  30 /****************************************************************************
  31 terminate sockent connection
  32 ****************************************************************************/
  33 static void free_sock(void *sock)
  34 {
  35         if (sock != NULL)
  36         {
  37                 struct msrpc_local *n = (struct msrpc_local*)sock;
  38                 msrpc_use_del(n->pipe_name, False, NULL);
  39         }
  40 }
  41
  42 static struct msrpc_local *init_client_connection(int c)
  43 {
  44         pstring buf;
  45         fstring pipe_name;
  46         int rl;
  47         uint32 len;
  48         BOOL new_con = False;
  49         struct msrpc_local *n = NULL;
  50
  51         CREDS_CMD cmd;
  52         prs_struct ps;
  53
  54         ZERO_STRUCT(cmd);
  55
  56         DEBUG(10,("init_client_connection: first request\n"));
  57
  58         rl = read(c, &buf, sizeof(len));
  59
  60         if (rl != sizeof(len))
  61         {
  62                 DEBUG(0,("Unable to read length\n"));
  63                 dump_data(0, buf, sizeof(len));
  64                 return NULL;
  65         }
  66
  67         len = IVAL(buf, 0);
  68
  69         if (len > sizeof(buf))
  70         {
  71                 DEBUG(0,("length %d too long\n", len));
  72                 return NULL;
  73         }
  74
  75         rl = read(c, buf, len);
  76
  77         if (rl < 0)
  78         {
  79                 DEBUG(0,("Unable to read from connection\n"));
  80                 return NULL;
  81         }
  82
  83 #ifdef DEBUG_PASSWORD
  84         dump_data(100, buf, rl);
  85 #endif
  86
  87         /* make a static data parsing structure from the api_fd_reply data */
  88         prs_create(&ps, buf, len, 4, True);
  89
  90         if (!creds_io_cmd("creds", &cmd, &ps, 0))
  91         {
  92                 DEBUG(0,("Unable to parse credentials\n"));
  93                 prs_free_data(&ps);
  94                 return NULL;
  95         }
  96
  97         prs_free_data(&ps);
  98
  99         if (ps.offset != rl)
 100         {
 101                 DEBUG(0,("Buffer size %d %d!\n", ps.offset, rl));
 102                 return NULL;
 103         }
 104
 105         switch (cmd.command)
 106         {
 107                 case AGENT_CMD_CON:
 108                 case AGENT_CMD_CON_ANON:
 109                 {
 110                         new_con = True;
 111                         break;
 112                 }
 113                 case AGENT_CMD_CON_REUSE:
 114                 {
 115                         new_con = True;
 116                         break;
 117                 }
 118                 default:
 119                 {
 120                         DEBUG(0,("unknown command %d\n", cmd.command));
 121                         return NULL;
 122                 }
 123         }
 124
 125         if (new_con)
 126         {
 127                 uint32 status = 0;
 128                 n = msrpc_use_add(pipe_name, &cmd.key, False);
 129
 130                 if (n == NULL)
 131                 {
 132                         DEBUG(0,("Unable to connect to %s\n", pipe_name));
 133                         status = 0x1;
 134                 }
 135                 else
 136                 {
 137                         fstrcpy(n->pipe_name, pipe_name);
 138                 }
 139
 140                 if (write(c, &status, sizeof(status)) != sizeof(status))
 141                 {
 142                         DEBUG(0,("Could not write connection down pipe.\n"));
 143                         if (n != NULL)
 144                         {
 145                                 msrpc_use_del(pipe_name, False, NULL);
 146                                 n = NULL;
 147                         }
 148                 }
 149         }
 150         return n;
 151 }
 152
 153 static BOOL process_cli_sock(struct sock_redir **socks, uint32 num_socks,
 154                                 struct sock_redir *sock)
 155 {
 156         struct msrpc_local *n = (struct msrpc_local*)sock->n;
 157         if (n == NULL)
 158         {
 159                 n = init_client_connection(sock->c);
 160                 if (n == NULL)
 161                 {
 162                         return False;
 163                 }
 164                 sock->n = (void*)n;
 165                 sock->s = n->fd;
 166         }
 167         else
 168         {
 169                 if (!receive_smb(sock->c, packet, 0))
 170                 {
 171                         DEBUG(0,("client closed connection\n"));
 172                         return False;
 173                 }
 174
 175                 if (!send_smb(sock->s, packet))
 176                 {
 177                         DEBUG(0,("server is dead\n"));
 178                         return False;
 179                 }
 180         }
 181         return True;
 182 }
 183
 184 static BOOL process_srv_sock(struct sock_redir **socks, uint32 num_socks,
 185                                 int fd)
 186 {
 187         int i;
 188         if (!receive_smb(fd, packet, 0))
 189         {
 190                 DEBUG(0,("server closed connection\n"));
 191                 return False;
 192         }
 193
 194         DEBUG(10,("process_srv_sock:\tfd:\t%d\n", fd));
 195
 196         for (i = 0; i < num_socks; i++)
 197         {
 198                 struct msrpc_local *n;
 199                 if (socks[i] == NULL || socks[i]->n == NULL)
 200                 {
 201                         continue;
 202                 }
 203                 n = (struct msrpc_local*)socks[i]->n;
 204                 DEBUG(10,("list:\tfd:\t%d\n",
 205                            socks[i]->s));
 206                 if (!send_smb(socks[i]->c, packet))
 207                 {
 208                         DEBUG(0,("client is dead\n"));
 209                         return False;
 210                 }
 211                 return True;
 212         }
 213         return False;
 214 }
 215
 216 static int get_agent_sock(char *pipe_name)
 217 {
 218         fstring path;
 219         fstring dir;
 220
 221         slprintf(dir, sizeof(dir)-1, "/tmp/.msrpc/.%s", pipe_name);
 222         slprintf(path, sizeof(path)-1, "%s/agent", dir);
 223
 224         return create_pipe_socket(dir, S_IRUSR|S_IWUSR|S_IXUSR, path, 0);
 225 }
 226
 227 void start_msrpc_agent(char *pipe_name)
 228 {
 229         struct vagent_ops va =
 230         {
 231                 free_sock,
 232                 get_agent_sock,
 233                 process_cli_sock,
 234                 process_srv_sock,
 235                 NULL,
 236                 NULL,
 237                 0
 238         };
 239
 240         if (sys_fork() == 0)
 241         {
 242                 /* child */
 243                 va.id = pipe_name;
 244                 start_agent(&va);
 245         }
 246 }
 247