home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 July & August / Pcwk78a98.iso / Wtestowe / Clico / UNIX / SAMBA / SOURCE / SAMBA.TAR / samba-1.9.17 / source / pipes.c < prev    next >
C/C++ Source or Header  |  1997-08-22  |  10KB  |  360 lines
  1. /* 
  2.    Unix SMB/Netbios implementation.
  3.    Version 1.9.
  4.    Pipe SMB reply routines
  5.    Copyright (C) Andrew Tridgell 1992-1997
  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.    This file handles reply_ calls on named pipes that the server
  23.    makes to handle specific protocols
  24. */
  25.  
  26.  
  27. #include "includes.h"
  28. #include "trans2.h"
  29.  
  30. #define    PIPE        "\\PIPE\\"
  31. #define    PIPELEN        strlen(PIPE)
  32.  
  33. #define REALLOC(ptr,size) Realloc(ptr,MAX((size),4*1024))
  34.  
  35. /* look in server.c for some explanation of these variables */
  36. extern int Protocol;
  37. extern int DEBUGLEVEL;
  38. extern int chain_fnum;
  39. extern char magic_char;
  40. extern connection_struct Connections[];
  41. extern files_struct Files[];
  42. extern BOOL case_sensitive;
  43. extern pstring sesssetup_user;
  44. extern int Client;
  45. extern fstring myworkgroup;
  46.  
  47. /* this macro should always be used to extract an fnum (smb_fid) from
  48. a packet to ensure chaining works correctly */
  49. #define GETFNUM(buf,where) (chain_fnum!= -1?chain_fnum:SVAL(buf,where))
  50.  
  51. char * known_pipes [] =
  52. {
  53.   "lsarpc",
  54.   NULL
  55. };
  56.  
  57. /****************************************************************************
  58.   reply to an open and X on a named pipe
  59.  
  60.   In fact what we do is to open a regular file with the same name in
  61.   /tmp. This can then be closed as normal. Reading and writing won't
  62.   make much sense, but will do *something*. The real reason for this
  63.   support is to be able to do transactions on them (well, on lsarpc
  64.   for domain login purposes...).
  65.  
  66.   This code is basically stolen from reply_open_and_X with some
  67.   wrinkles to handle pipes.
  68. ****************************************************************************/
  69. int reply_open_pipe_and_X(char *inbuf,char *outbuf,int length,int bufsize)
  70. {
  71.   pstring fname;
  72.   int cnum = SVAL(inbuf,smb_tid);
  73.   int fnum = -1;
  74.   int smb_mode = SVAL(inbuf,smb_vwv3);
  75.   int smb_attr = SVAL(inbuf,smb_vwv5);
  76. #if 0
  77.   int open_flags = SVAL(inbuf,smb_vwv2);
  78.   int smb_sattr = SVAL(inbuf,smb_vwv4); 
  79.   uint32 smb_time = make_unix_date3(inbuf+smb_vwv6);
  80. #endif
  81.   int smb_ofun = SVAL(inbuf,smb_vwv8);
  82.   int unixmode;
  83.   int size=0,fmode=0,mtime=0,rmode=0;
  84.   struct stat sbuf;
  85.   int smb_action = 0;
  86.   int i;
  87.   BOOL bad_path = False;
  88.  
  89.   /* XXXX we need to handle passed times, sattr and flags */
  90.   strcpy(fname,smb_buf(inbuf));
  91.  
  92.   /* If the name doesn't start \PIPE\ then this is directed */
  93.   /* at a mailslot or something we really, really don't understand, */
  94.   /* not just something we really don't understand. */
  95.   if ( strncmp(fname,PIPE,PIPELEN) != 0 )
  96.     return(ERROR(ERRSRV,ERRaccess));
  97.  
  98.   DEBUG(4,("Opening pipe %s.\n", fname));
  99.  
  100.   /* Strip \PIPE\ off the name. */
  101.   strcpy(fname,smb_buf(inbuf) + PIPELEN);
  102.  
  103.   /* See if it is one we want to handle. */
  104.   for( i = 0; known_pipes[i] ; i++ )
  105.     if( strcmp(fname,known_pipes[i]) == 0 )
  106.       break;
  107.  
  108.   if ( known_pipes[i] == NULL )
  109.     return(ERROR(ERRSRV,ERRaccess));
  110.  
  111.   /* Known pipes arrive with DIR attribs. Remove it so a regular file */
  112.   /* can be opened and add it in after the open. */
  113.   DEBUG(3,("Known pipe %s opening.\n",fname));
  114.   smb_attr &= ~aDIR;
  115.   Connections[cnum].read_only = 0;
  116.   smb_ofun |= 0x10;        /* Add Create it not exists flag */
  117.  
  118.   unix_convert(fname,cnum,0,&bad_path);
  119.     
  120.   fnum = find_free_file();
  121.   if (fnum < 0)
  122.     return(ERROR(ERRSRV,ERRnofids));
  123.  
  124.   if (!check_name(fname,cnum))
  125.     return(UNIXERROR(ERRDOS,ERRnoaccess));
  126.  
  127.   unixmode = unix_mode(cnum,smb_attr);
  128.       
  129.   open_file_shared(fnum,cnum,fname,smb_mode,smb_ofun,unixmode,
  130.            &rmode,&smb_action);
  131.       
  132.   if (!Files[fnum].open)
  133.   {
  134.     /* Change the error code if bad_path was set. */
  135.     if((errno == ENOENT) && bad_path)
  136.     {
  137.       unix_ERR_class = ERRDOS;
  138.       unix_ERR_code = ERRbadpath;
  139.     }
  140.     return(UNIXERROR(ERRDOS,ERRnoaccess));
  141.   }
  142.  
  143.   if (fstat(Files[fnum].fd_ptr->fd,&sbuf) != 0) {
  144.     close_file(fnum);
  145.     return(ERROR(ERRDOS,ERRnoaccess));
  146.   }
  147.  
  148.   size = sbuf.st_size;
  149.   fmode = dos_mode(cnum,fname,&sbuf);
  150.   mtime = sbuf.st_mtime;
  151.   if (fmode & aDIR) {
  152.     close_file(fnum);
  153.     return(ERROR(ERRDOS,ERRnoaccess));
  154.   }
  155.  
  156.   /* Prepare the reply */
  157.   set_message(outbuf,15,0,True);
  158.  
  159.   /* Put things back the way they were. */
  160.   Connections[cnum].read_only = 1;
  161.  
  162.   /* Mark the opened file as an existing named pipe in message mode. */
  163.   SSVAL(outbuf,smb_vwv9,2);
  164.   SSVAL(outbuf,smb_vwv10,0xc700);
  165.   if (rmode == 2)
  166.   {
  167.     DEBUG(4,("Resetting open result to open from create.\n"));
  168.     rmode = 1;
  169.   }
  170.  
  171.   SSVAL(outbuf,smb_vwv2,fnum);
  172.   SSVAL(outbuf,smb_vwv3,fmode);
  173.   put_dos_date3(outbuf,smb_vwv4,mtime);
  174.   SIVAL(outbuf,smb_vwv6,size);
  175.   SSVAL(outbuf,smb_vwv8,rmode);
  176.   SSVAL(outbuf,smb_vwv11,smb_action);
  177.  
  178.   chain_fnum = fnum;
  179.  
  180.   DEBUG(4,("Opened pipe %s with handle %d, saved name %s.\n",
  181.        fname, fnum, Files[fnum].name));
  182.   
  183.   return chain_reply(inbuf,outbuf,length,bufsize);
  184. }
  185.  
  186.  
  187. /****************************************************************************
  188.  api_LsarpcSNPHS
  189.  
  190.  SetNamedPipeHandleState on \PIPE\lsarpc. We can't really do much here,
  191.  so just blithely return True. This is really only for NT domain stuff,
  192.  we we're only handling that - don't assume Samba now does complete
  193.  named pipe handling.
  194. ****************************************************************************/
  195. BOOL api_LsarpcSNPHS(int cnum,int uid, char *param,char *data,
  196.              int mdrcnt,int mprcnt,
  197.              char **rdata,char **rparam,
  198.              int *rdata_len,int *rparam_len)
  199. {
  200.   uint16 id;
  201.  
  202.   id = param[0] + (param[1] << 8);
  203.   DEBUG(4,("lsarpc SetNamedPipeHandleState to code %x\n",id));
  204.   return(True);
  205. }
  206.  
  207.  
  208. /****************************************************************************
  209.  api_LsarpcTNP
  210.  
  211.  TransactNamedPipe on \PIPE\lsarpc.
  212. ****************************************************************************/
  213. static void LsarpcTNP1(char *data,char **rdata, int *rdata_len)
  214. {
  215.   uint32 dword1, dword2;
  216.   char pname[] = "\\PIPE\\lsass";
  217.  
  218.   /* All kinds of mysterious numbers here */
  219.   *rdata_len = 68;
  220.   *rdata = REALLOC(*rdata,*rdata_len);
  221.  
  222.   dword1 = IVAL(data,0xC);
  223.   dword2 = IVAL(data,0x10);
  224.  
  225.   SIVAL(*rdata,0,0xc0005);
  226.   SIVAL(*rdata,4,0x10);
  227.   SIVAL(*rdata,8,0x44);
  228.   SIVAL(*rdata,0xC,dword1);
  229.   
  230.   SIVAL(*rdata,0x10,dword2);
  231.   SIVAL(*rdata,0x14,0x15);
  232.   SSVAL(*rdata,0x18,sizeof(pname));
  233.   strcpy(*rdata + 0x1a,pname);
  234.   SIVAL(*rdata,0x28,1);
  235.   memcpy(*rdata + 0x30, data + 0x34, 0x14);
  236. }
  237.  
  238. static void LsarpcTNP2(char *data,char **rdata, int *rdata_len)
  239. {
  240.   uint32 dword1;
  241.  
  242.   /* All kinds of mysterious numbers here */
  243.   *rdata_len = 48;
  244.   *rdata = REALLOC(*rdata,*rdata_len);
  245.  
  246.   dword1 = IVAL(data,0xC);
  247.  
  248.   SIVAL(*rdata,0,0x03020005);
  249.   SIVAL(*rdata,4,0x10);
  250.   SIVAL(*rdata,8,0x30);
  251.   SIVAL(*rdata,0xC,dword1);
  252.   SIVAL(*rdata,0x10,0x18);
  253.   SIVAL(*rdata,0x1c,0x44332211);
  254.   SIVAL(*rdata,0x20,0x88776655);
  255.   SIVAL(*rdata,0x24,0xCCBBAA99);
  256.   SIVAL(*rdata,0x28,0x11FFEEDD);
  257. }
  258.  
  259. static void LsarpcTNP3(char *data,char **rdata, int *rdata_len)
  260. {
  261.   uint32 dword1;
  262.   uint16 word1;
  263.   char * workgroup = myworkgroup;
  264.   int wglen = strlen(workgroup);
  265.   int i;
  266.  
  267.   /* All kinds of mysterious numbers here */
  268.   *rdata_len = 90 + 2 * wglen;
  269.   *rdata = REALLOC(*rdata,*rdata_len);
  270.  
  271.   dword1 = IVAL(data,0xC);
  272.   word1 = SVAL(data,0x2C);
  273.  
  274.   SIVAL(*rdata,0,0x03020005);
  275.   SIVAL(*rdata,4,0x10);
  276.   SIVAL(*rdata,8,0x60);
  277.   SIVAL(*rdata,0xC,dword1);
  278.   SIVAL(*rdata,0x10,0x48);
  279.   SSVAL(*rdata,0x18,0x5988);    /* This changes */
  280.   SSVAL(*rdata,0x1A,0x15);
  281.   SSVAL(*rdata,0x1C,word1);
  282.   SSVAL(*rdata,0x20,6);
  283.   SSVAL(*rdata,0x22,8);
  284.   SSVAL(*rdata,0x24,0x8E8);    /* So does this */
  285.   SSVAL(*rdata,0x26,0x15);
  286.   SSVAL(*rdata,0x28,0x4D48);    /* And this */
  287.   SSVAL(*rdata,0x2A,0x15);
  288.   SIVAL(*rdata,0x2C,4);
  289.   SIVAL(*rdata,0x34,wglen);
  290.   for ( i = 0 ; i < wglen ; i++ )
  291.     (*rdata)[0x38 + i * 2] = workgroup[i];
  292.    
  293.   /* Now fill in the rest */
  294.   i = 0x38 + wglen * 2;
  295.   SSVAL(*rdata,i,0x648);
  296.   SIVAL(*rdata,i+2,4);
  297.   SIVAL(*rdata,i+6,0x401);
  298.   SSVAL(*rdata,i+0xC,0x500);
  299.   SIVAL(*rdata,i+0xE,0x15);
  300.   SIVAL(*rdata,i+0x12,0x2372FE1);
  301.   SIVAL(*rdata,i+0x16,0x7E831BEF);
  302.   SIVAL(*rdata,i+0x1A,0x4B454B2);
  303. }
  304.  
  305. static void LsarpcTNP4(char *data,char **rdata, int *rdata_len)
  306. {
  307.   uint32 dword1;
  308.  
  309.   /* All kinds of mysterious numbers here */
  310.   *rdata_len = 48;
  311.   *rdata = REALLOC(*rdata,*rdata_len);
  312.  
  313.   dword1 = IVAL(data,0xC);
  314.  
  315.   SIVAL(*rdata,0,0x03020005);
  316.   SIVAL(*rdata,4,0x10);
  317.   SIVAL(*rdata,8,0x30);
  318.   SIVAL(*rdata,0xC,dword1);
  319.   SIVAL(*rdata,0x10,0x18);
  320. }
  321.  
  322.  
  323. BOOL api_LsarpcTNP(int cnum,int uid, char *param,char *data,
  324.              int mdrcnt,int mprcnt,
  325.              char **rdata,char **rparam,
  326.              int *rdata_len,int *rparam_len)
  327. {
  328.   uint32 id,id2;
  329.  
  330.   id = IVAL(data,0);
  331.  
  332.   DEBUG(4,("lsarpc TransactNamedPipe id %lx\n",id));
  333.   switch (id)
  334.   {
  335.     case 0xb0005:
  336.       LsarpcTNP1(data,rdata,rdata_len);
  337.       break;
  338.  
  339.     case 0x03000005:
  340.       id2 = IVAL(data,8);
  341.       DEBUG(4,("\t- Suboperation %lx\n",id2));
  342.       switch (id2 & 0xF)
  343.       {
  344.         case 8:
  345.           LsarpcTNP2(data,rdata,rdata_len);
  346.           break;
  347.  
  348.         case 0xC:
  349.           LsarpcTNP4(data,rdata,rdata_len);
  350.           break;
  351.  
  352.         case 0xE:
  353.           LsarpcTNP3(data,rdata,rdata_len);
  354.           break;
  355.       }
  356.       break;
  357.   }
  358.   return(True);
  359. }
  360.