becfd01504d92017e4861c59ca659d7e73c1b25d
[kai/samba.git] / source / smbd / service.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    service (connection) opening and closing
5    Copyright (C) Andrew Tridgell 1992-1998
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
24 extern int DEBUGLEVEL;
25
26 extern time_t smb_last_time;
27 extern int case_default;
28 extern BOOL case_preserve;
29 extern BOOL short_case_preserve;
30 extern BOOL case_mangle;
31 extern BOOL case_sensitive;
32 extern BOOL use_mangled_map;
33 extern fstring remote_machine;
34 extern pstring sesssetup_user;
35 extern fstring remote_machine;
36
37
38 /****************************************************************************
39 load parameters specific to a connection/service
40 ****************************************************************************/
41 BOOL become_service(connection_struct *conn,BOOL do_chdir)
42 {
43         extern char magic_char;
44         static connection_struct *last_conn;
45         int snum;
46
47         if (!conn)  {
48                 last_conn = NULL;
49                 return(False);
50         }
51
52         conn->lastused = smb_last_time;
53
54         snum = SNUM(conn);
55   
56         if (do_chdir &&
57             dos_ChDir(conn->connectpath) != 0 &&
58             dos_ChDir(conn->origpath) != 0) {
59                 DEBUG(0,("chdir (%s) failed\n",
60                          conn->connectpath));
61                 return(False);
62         }
63
64         if (conn == last_conn)
65                 return(True);
66
67         last_conn = conn;
68
69         case_default = lp_defaultcase(snum);
70         case_preserve = lp_preservecase(snum);
71         short_case_preserve = lp_shortpreservecase(snum);
72         case_mangle = lp_casemangle(snum);
73         case_sensitive = lp_casesensitive(snum);
74         magic_char = lp_magicchar(snum);
75         use_mangled_map = (*lp_mangled_map(snum) ? True:False);
76         return(True);
77 }
78
79
80 /****************************************************************************
81   find a service entry
82 ****************************************************************************/
83 int find_service(char *service)
84 {
85    int iService;
86
87    string_sub(service,"\\","/");
88
89    iService = lp_servicenumber(service);
90
91    /* now handle the special case of a home directory */
92    if (iService < 0)
93    {
94       char *phome_dir = get_home_dir(service);
95         pstring home_dir;
96
97       if(phome_dir == NULL)
98       {
99         /*
100          * Try mapping the servicename, it may
101          * be a Windows to unix mapped user name.
102          */
103         if(map_username(service))
104           phome_dir = get_home_dir(service);
105       }
106
107       DEBUG(3,("checking for home directory %s gave %s\n",service,
108             phome_dir?phome_dir:"(NULL)"));
109
110       if (phome_dir)
111       {   
112         int iHomeService;
113         pstrcpy(home_dir, phome_dir);
114         if ((iHomeService = lp_servicenumber(HOMES_NAME)) >= 0)
115         {
116           lp_add_home(service,iHomeService,home_dir);
117           iService = lp_servicenumber(service);
118         }
119       }
120    }
121
122    /* If we still don't have a service, attempt to add it as a printer. */
123    if (iService < 0)
124    {
125       int iPrinterService;
126
127       if ((iPrinterService = lp_servicenumber(PRINTERS_NAME)) >= 0)
128       {
129          char *pszTemp;
130
131          DEBUG(3,("checking whether %s is a valid printer name...\n", service));
132          pszTemp = PRINTCAP;
133          if ((pszTemp != NULL) && pcap_printername_ok(service, pszTemp))
134          {
135             DEBUG(3,("%s is a valid printer name\n", service));
136             DEBUG(3,("adding %s as a printer service\n", service));
137             lp_add_printer(service,iPrinterService);
138             iService = lp_servicenumber(service);
139             if (iService < 0)
140                DEBUG(0,("failed to add %s as a printer service!\n", service));
141          }
142          else
143             DEBUG(3,("%s is not a valid printer name\n", service));
144       }
145    }
146
147    /* Check for default vfs service?  Unsure whether to implement this */
148    if (iService < 0)
149    {
150    }
151
152    /* just possibly it's a default service? */
153    if (iService < 0) 
154    {
155      char *pdefservice = lp_defaultservice();
156      if (pdefservice && *pdefservice && 
157          !strequal(pdefservice,service) &&
158          !strstr(service,".."))
159      {
160        /*
161         * We need to do a local copy here as lp_defaultservice() 
162         * returns one of the rotating lp_string buffers that
163         * could get overwritten by the recursive find_service() call
164         * below. Fix from Josef Hinteregger <joehtg@joehtg.co.at>.
165         */
166        pstring defservice;
167        pstrcpy(defservice, pdefservice);
168        iService = find_service(defservice);
169        if (iService >= 0)
170        {
171          string_sub(service,"_","/");
172          iService = lp_add_service(service,iService);
173        }
174      }
175    }
176
177    if (iService >= 0)
178      if (!VALID_SNUM(iService))
179      {
180        DEBUG(0,("Invalid snum %d for %s\n",iService,service));
181        iService = -1;
182      }
183
184    if (iService < 0)
185      DEBUG(3,("find_service() failed to find service %s\n", service));
186
187    return (iService);
188 }
189
190
191 /****************************************************************************
192   make a connection to a service
193 ****************************************************************************/
194 connection_struct *make_connection(char *service,char *user,char *password, int pwlen, char *dev,uint16 vuid, int *ecode)
195 {
196         int snum;
197         const struct passwd *pass = NULL;
198         BOOL guest = False;
199         BOOL force = False;
200         extern int Client;
201         connection_struct *conn;
202
203         strlower(service);
204
205         snum = find_service(service);
206         if (snum < 0) {
207                 extern int Client;
208                 if (strequal(service,"IPC$")) {
209                         DEBUG(3,("refusing IPC connection\n"));
210                         *ecode = ERRnoipc;
211                         return NULL;
212                 }
213
214                 DEBUG(0,("%s (%s) couldn't find service %s\n",
215                          remote_machine, client_addr(Client), service));
216                 *ecode = ERRinvnetname;
217                 return NULL;
218         }
219
220         if (strequal(service,HOMES_NAME)) {
221                 if (*user && Get_Pwnam(user,True))
222                         return(make_connection(user,user,password,
223                                                pwlen,dev,vuid,ecode));
224
225                 if(lp_security() != SEC_SHARE) {
226                         if (validated_username(vuid)) {
227                                 pstrcpy(user,validated_username(vuid));
228                                 return(make_connection(user,user,password,pwlen,dev,vuid,ecode));
229                         }
230                 } else {
231                         /* Security = share. Try with sesssetup_user
232                          * as the username.  */
233                         if(*sesssetup_user) {
234                                 pstrcpy(user,sesssetup_user);
235                                 return(make_connection(user,user,password,pwlen,dev,vuid,ecode));
236                         }
237                 }
238         }
239
240         if (!lp_snum_ok(snum) || 
241             !check_access(Client, 
242                           lp_hostsallow(snum), lp_hostsdeny(snum))) {    
243                 *ecode = ERRaccess;
244                 return NULL;
245         }
246
247         /* you can only connect to the IPC$ service as an ipc device */
248         if (strequal(service,"IPC$"))
249                 pstrcpy(dev,"IPC");
250         
251         if (*dev == '?' || !*dev) {
252                 if (lp_print_ok(snum)) {
253                         pstrcpy(dev,"LPT1:");
254                 } else {
255                         pstrcpy(dev,"A:");
256                 }
257         }
258
259         /* if the request is as a printer and you can't print then refuse */
260         strupper(dev);
261         if (!lp_print_ok(snum) && (strncmp(dev,"LPT",3) == 0)) {
262                 DEBUG(1,("Attempt to connect to non-printer as a printer\n"));
263                 *ecode = ERRinvdevice;
264                 return NULL;
265         }
266
267         /* lowercase the user name */
268         strlower(user);
269
270         /* add it as a possible user name */
271         add_session_user(service);
272
273         /* shall we let them in? */
274         if (!authorise_login(snum,user,password,pwlen,&guest,&force,vuid)) {
275                 DEBUG( 2, ( "Invalid username/password for %s\n", service ) );
276                 *ecode = ERRbadpw;
277                 return NULL;
278         }
279   
280         conn = conn_new();
281         if (!conn) {
282                 DEBUG(0,("Couldn't find free connection.\n"));
283                 *ecode = ERRnoresource;
284                 conn_free(conn);
285                 return NULL;
286         }
287
288         /* find out some info about the user */
289         pass = Get_Pwnam(user,True);
290
291         if (pass == NULL) {
292                 DEBUG(0,( "Couldn't find account %s\n",user));
293                 *ecode = ERRbaduid;
294                 conn_free(conn);
295                 return NULL;
296         }
297
298         conn->read_only = lp_readonly(snum);
299
300         {
301                 pstring list;
302                 StrnCpy(list,lp_readlist(snum),sizeof(pstring)-1);
303                 string_sub(list,"%S",service);
304
305                 if (user_in_list(user,list))
306                         conn->read_only = True;
307                 
308                 StrnCpy(list,lp_writelist(snum),sizeof(pstring)-1);
309                 string_sub(list,"%S",service);
310                 
311                 if (user_in_list(user,list))
312                         conn->read_only = False;    
313         }
314
315         /* admin user check */
316         
317         /* JRA - original code denied admin user if the share was
318            marked read_only. Changed as I don't think this is needed,
319            but old code left in case there is a problem here.
320         */
321         if (user_in_list(user,lp_admin_users(snum)) 
322 #if 0
323             && !conn->read_only
324 #endif
325             ) {
326                 conn->admin_user = True;
327                 DEBUG(0,("%s logged in as admin user (root privileges)\n",user));
328         } else {
329                 conn->admin_user = False;
330         }
331     
332         conn->force_user = force;
333         conn->vuid = vuid;
334         conn->uid = pass->pw_uid;
335         conn->gid = pass->pw_gid;
336         conn->num_files_open = 0;
337         conn->lastused = time(NULL);
338         conn->service = snum;
339         conn->used = True;
340         conn->printer = (strncmp(dev,"LPT",3) == 0);
341         conn->ipc = (strncmp(dev,"IPC",3) == 0);
342         conn->dirptr = NULL;
343         conn->veto_list = NULL;
344         conn->hide_list = NULL;
345         conn->veto_oplock_list = NULL;
346         string_set(&conn->dirpath,"");
347         string_set(&conn->user,user);
348
349         /* Initialise VFS function pointers */
350
351         if (*lp_vfsobj(SNUM(conn))) {
352
353 #ifdef HAVE_LIBDL
354
355             /* Loadable object file */
356
357             if (!vfs_init_custom(conn)) {
358                 return NULL;
359             }
360 #else
361             DEBUG(0, ("No libdl present - cannot use VFS objects\n"));
362             conn_free(conn);
363             return NULL;
364 #endif
365
366         } else {
367
368             /* Normal share - initialise with disk access functions */
369
370             vfs_init_default(conn);
371         }
372
373 #ifdef HAVE_GETGRNAM 
374         if (*lp_force_group(snum)) {
375                 struct group *gptr;
376                 pstring gname;
377                 
378                 StrnCpy(gname,lp_force_group(snum),sizeof(pstring)-1);
379                 /* default service may be a group name          */
380                 string_sub(gname,"%S",service);
381                 gptr = (struct group *)getgrnam(gname);
382                 
383                 if (gptr) {
384                         conn->gid = gptr->gr_gid;
385                         DEBUG(3,("Forced group %s\n",gname));
386                 } else {
387                         DEBUG(1,("Couldn't find group %s\n",gname));
388                 }
389         }
390 #endif
391         
392         if (*lp_force_user(snum)) {
393                 struct passwd *pass2;
394                 fstring fuser;
395                 fstrcpy(fuser,lp_force_user(snum));
396                 pass2 = (struct passwd *)Get_Pwnam(fuser,True);
397                 if (pass2) {
398                         conn->uid = pass2->pw_uid;
399                         string_set(&conn->user,fuser);
400                         fstrcpy(user,fuser);
401                         conn->force_user = True;
402                         DEBUG(3,("Forced user %s\n",fuser));      
403                 } else {
404                         DEBUG(1,("Couldn't find user %s\n",fuser));
405                 }
406         }
407
408         {
409                 pstring s;
410                 pstrcpy(s,lp_pathname(snum));
411                 standard_sub(conn,s);
412                 string_set(&conn->connectpath,s);
413                 DEBUG(3,("Connect path is %s\n",s));
414         }
415
416         /* groups stuff added by ih */
417         conn->ngroups = 0;
418         conn->groups = NULL;
419         
420         if (!IS_IPC(conn)) {
421                 /* Find all the groups this uid is in and
422                    store them. Used by become_user() */
423                 get_unixgroups(conn->user,conn->uid,conn->gid,
424                              &conn->ngroups,&conn->groups);
425                 
426                 /* check number of connections */
427                 if (!claim_connection(conn,
428                                       lp_servicename(SNUM(conn)),
429                                       lp_max_connections(SNUM(conn)),
430                                       False)) {
431                         DEBUG(1,("too many connections - rejected\n"));
432                         *ecode = ERRnoresource;
433                         conn_free(conn);
434                         return NULL;
435                 }  
436                 
437                 if (lp_status(SNUM(conn)))
438                         claim_connection(conn,"STATUS.",
439                                          MAXSTATUS,False);
440         } /* IS_IPC */
441         
442         /* execute any "root preexec = " line */
443         if (*lp_rootpreexec(SNUM(conn))) {
444                 pstring cmd;
445                 pstrcpy(cmd,lp_rootpreexec(SNUM(conn)));
446                 standard_sub(conn,cmd);
447                 DEBUG(5,("cmd=%s\n",cmd));
448                 smbrun(cmd,NULL,False);
449         }
450         
451         if (!become_user(conn, conn->vuid)) {
452                 DEBUG(0,("Can't become connected user!\n"));
453                 if (!IS_IPC(conn)) {
454                         yield_connection(conn,
455                                          lp_servicename(SNUM(conn)),
456                                          lp_max_connections(SNUM(conn)));
457                         if (lp_status(SNUM(conn))) {
458                                 yield_connection(conn,"STATUS.",MAXSTATUS);
459                         }
460                 }
461                 conn_free(conn);
462                 *ecode = ERRbadpw;
463                 return NULL;
464         }
465         
466         if (dos_ChDir(conn->connectpath) != 0) {
467                 DEBUG(0,("Can't change directory to %s (%s)\n",
468                          conn->connectpath,strerror(errno)));
469                 unbecome_user();
470                 if (!IS_IPC(conn)) {
471                         yield_connection(conn,
472                                          lp_servicename(SNUM(conn)),
473                                          lp_max_connections(SNUM(conn)));
474                         if (lp_status(SNUM(conn))) 
475                                 yield_connection(conn,"STATUS.",MAXSTATUS);
476                 }
477                 conn_free(conn);
478                 *ecode = ERRinvnetname;
479                 return NULL;
480         }
481         
482         string_set(&conn->origpath,conn->connectpath);
483         
484 #if SOFTLINK_OPTIMISATION
485         /* resolve any soft links early */
486         {
487                 pstring s;
488                 pstrcpy(s,conn->connectpath);
489                 dos_GetWd(s);
490                 string_set(&conn->connectpath,s);
491                 dos_ChDir(conn->connectpath);
492         }
493 #endif
494         
495         add_session_user(user);
496                 
497         /* execute any "preexec = " line */
498         if (*lp_preexec(SNUM(conn))) {
499                 pstring cmd;
500                 pstrcpy(cmd,lp_preexec(SNUM(conn)));
501                 standard_sub(conn,cmd);
502                 smbrun(cmd,NULL,False);
503         }
504         
505         /* we've finished with the sensitive stuff */
506         unbecome_user();
507         
508         /* Add veto/hide lists */
509         if (!IS_IPC(conn) && !IS_PRINT(conn)) {
510                 set_namearray( &conn->veto_list, lp_veto_files(SNUM(conn)));
511                 set_namearray( &conn->hide_list, lp_hide_files(SNUM(conn)));
512                 set_namearray( &conn->veto_oplock_list, lp_veto_oplocks(SNUM(conn)));
513         }
514         
515         if( DEBUGLVL( IS_IPC(conn) ? 3 : 1 ) ) {
516                 extern int Client;
517                 
518                 dbgtext( "%s (%s) ", remote_machine, client_addr(Client) );
519                 dbgtext( "connect to service %s ", lp_servicename(SNUM(conn)));
520                 dbgtext( "as user %s ", user );
521                 dbgtext( "(uid=%d, gid=%d) ", (int)conn->uid, (int)conn->gid );
522                 dbgtext( "(pid %d)\n", (int)getpid() );
523         }
524
525         /* Invoke make connection hook */
526
527         if (conn->vfs_ops.connect) {
528             struct vfs_connection_struct *vconn;
529
530             vconn = (struct vfs_connection_struct *)
531                 malloc(sizeof(struct vfs_connection_struct));
532
533             if (vconn == NULL) {
534                 DEBUG(0, ("No memory to create vfs_connection_struct"));
535                 return NULL;
536             }
537
538             ZERO_STRUCTP(vconn);
539
540             /* Copy across relevant data from connection struct */
541
542             vconn->printer = conn->printer;
543             vconn->ipc = conn->ipc;
544             vconn->read_only = conn->read_only;
545             vconn->admin_user = conn->admin_user;
546
547             pstrcpy(vconn->dirpath, conn->dirpath);
548             pstrcpy(vconn->connectpath, conn->connectpath);
549             pstrcpy(vconn->origpath, conn->origpath);
550
551             pstrcpy(vconn->user, conn->user);
552             vconn->uid = conn->uid;
553             vconn->gid = conn->gid;
554             vconn->ngroups = conn->ngroups;
555             vconn->groups = (gid_t *)malloc(conn->ngroups * sizeof(gid_t));
556             if (vconn->groups != NULL) {
557                 memcpy(vconn->groups, conn->groups, 
558                        conn->ngroups * sizeof(gid_t));
559             }
560
561             /* Call connect hook */
562             
563             if (conn->vfs_ops.connect(vconn, service, user) < 0) {
564                 return NULL;
565             }
566         }
567         
568         return(conn);
569 }
570
571
572 /****************************************************************************
573 close a cnum
574 ****************************************************************************/
575 void close_cnum(connection_struct *conn, uint16 vuid)
576 {
577         extern int Client;
578         DirCacheFlush(SNUM(conn));
579
580         unbecome_user();
581
582         DEBUG(IS_IPC(conn)?3:1, ("%s (%s) closed connection to service %s\n",
583                                  remote_machine,client_addr(Client),
584                                  lp_servicename(SNUM(conn))));
585
586         if (conn->vfs_ops.disconnect != NULL) {
587
588             /* Call disconnect hook */
589             
590             conn->vfs_ops.disconnect();
591             
592             /* Free vfs_connection_struct */
593             
594             if (conn->vfs_conn != NULL) {
595                 if (conn->vfs_conn->groups != NULL) {
596                     free(conn->vfs_conn->groups);
597                 }
598                 free(conn->vfs_conn);
599             }
600         }
601
602         yield_connection(conn,
603                          lp_servicename(SNUM(conn)),
604                          lp_max_connections(SNUM(conn)));
605
606         if (lp_status(SNUM(conn)))
607                 yield_connection(conn,"STATUS.",MAXSTATUS);
608
609         file_close_conn(conn);
610         dptr_closecnum(conn);
611
612         /* execute any "postexec = " line */
613         if (*lp_postexec(SNUM(conn)) && 
614             become_user(conn, vuid))  {
615                 pstring cmd;
616                 pstrcpy(cmd,lp_postexec(SNUM(conn)));
617                 standard_sub(conn,cmd);
618                 smbrun(cmd,NULL,False);
619                 unbecome_user();
620         }
621
622         unbecome_user();
623         /* execute any "root postexec = " line */
624         if (*lp_rootpostexec(SNUM(conn)))  {
625                 pstring cmd;
626                 pstrcpy(cmd,lp_rootpostexec(SNUM(conn)));
627                 standard_sub(conn,cmd);
628                 smbrun(cmd,NULL,False);
629         }
630         
631         conn_free(conn);
632 }
633
634