source3/printing/nt_printing.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-2000,
   5  *  Copyright (C) Jean François Micouleau      1998-2000.
   6  *  Copyright (C) Gerald Carter                2002-2005.
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 3 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "includes.h"
  23 #include "librpc/gen_ndr/messaging.h"
  24 #include "printing/pcap.h"
  25 #include "printing/nt_printing_tdb.h"
  26 #include "printing/nt_printing_migrate.h"
  27 #include "registry.h"
  28 #include "registry/reg_objects.h"
  29 #include "../librpc/gen_ndr/ndr_security.h"
  30 #include "../librpc/gen_ndr/ndr_spoolss.h"
  31 #include "rpc_server/spoolss/srv_spoolss_util.h"
  32 #include "nt_printing.h"
  33 #include "secrets.h"
  34 #include "../librpc/gen_ndr/netlogon.h"
  35 #include "../libcli/security/security.h"
  36
  37 /* Map generic permissions to printer object specific permissions */
  38
  39 const struct generic_mapping printer_generic_mapping = {
  40         PRINTER_READ,
  41         PRINTER_WRITE,
  42         PRINTER_EXECUTE,
  43         PRINTER_ALL_ACCESS
  44 };
  45
  46 /* Map generic permissions to print server object specific permissions */
  47
  48 const struct generic_mapping printserver_generic_mapping = {
  49         SERVER_READ,
  50         SERVER_WRITE,
  51         SERVER_EXECUTE,
  52         SERVER_ALL_ACCESS
  53 };
  54
  55 /* Map generic permissions to job object specific permissions */
  56
  57 const struct generic_mapping job_generic_mapping = {
  58         JOB_READ,
  59         JOB_WRITE,
  60         JOB_EXECUTE,
  61         JOB_ALL_ACCESS
  62 };
  63
  64 static const struct print_architecture_table_node archi_table[]= {
  65
  66         {"Windows 4.0",          SPL_ARCH_WIN40,        0 },
  67         {"Windows NT x86",       SPL_ARCH_W32X86,       2 },
  68         {"Windows NT R4000",     SPL_ARCH_W32MIPS,      2 },
  69         {"Windows NT Alpha_AXP", SPL_ARCH_W32ALPHA,     2 },
  70         {"Windows NT PowerPC",   SPL_ARCH_W32PPC,       2 },
  71         {"Windows IA64",         SPL_ARCH_IA64,         3 },
  72         {"Windows x64",          SPL_ARCH_X64,          3 },
  73         {NULL,                   "",            -1 }
  74 };
  75
  76 /****************************************************************************
  77  Open the NT printing tdbs. Done once before fork().
  78 ****************************************************************************/
  79
  80 bool nt_printing_init(struct messaging_context *msg_ctx)
  81 {
  82         WERROR win_rc;
  83
  84         if (!nt_printing_tdb_upgrade()) {
  85                 return false;
  86         }
  87
  88         /*
  89          * register callback to handle updating printers as new
  90          * drivers are installed
  91          */
  92         messaging_register(msg_ctx, NULL, MSG_PRINTER_DRVUPGRADE,
  93                            do_drv_upgrade_printer);
  94
  95         /* of course, none of the message callbacks matter if you don't
  96            tell messages.c that you interested in receiving PRINT_GENERAL
  97            msgs.  This is done in serverid_register() */
  98
  99         if ( lp_security() == SEC_ADS ) {
 100                 win_rc = check_published_printers(msg_ctx);
 101                 if (!W_ERROR_IS_OK(win_rc))
 102                         DEBUG(0, ("nt_printing_init: error checking published printers: %s\n", win_errstr(win_rc)));
 103         }
 104
 105         return true;
 106 }
 107
 108 /*******************************************************************
 109  Function to allow filename parsing "the old way".
 110 ********************************************************************/
 111
 112 static NTSTATUS driver_unix_convert(connection_struct *conn,
 113                                     const char *old_name,
 114                                     struct smb_filename **smb_fname)
 115 {
 116         NTSTATUS status;
 117         TALLOC_CTX *ctx = talloc_tos();
 118         char *name = talloc_strdup(ctx, old_name);
 119
 120         if (!name) {
 121                 return NT_STATUS_NO_MEMORY;
 122         }
 123         unix_format(name);
 124         name = unix_clean_name(ctx, name);
 125         if (!name) {
 126                 return NT_STATUS_NO_MEMORY;
 127         }
 128         trim_string(name,"/","/");
 129
 130         status = unix_convert(ctx, conn, name, smb_fname, 0);
 131         if (!NT_STATUS_IS_OK(status)) {
 132                 return NT_STATUS_NO_MEMORY;
 133         }
 134
 135         return NT_STATUS_OK;
 136 }
 137
 138 /****************************************************************************
 139  Function to do the mapping between the long architecture name and
 140  the short one.
 141 ****************************************************************************/
 142
 143 const char *get_short_archi(const char *long_archi)
 144 {
 145         int i=-1;
 146
 147         DEBUG(107,("Getting architecture dependent directory\n"));
 148         do {
 149                 i++;
 150         } while ( (archi_table[i].long_archi!=NULL ) &&
 151                   StrCaseCmp(long_archi, archi_table[i].long_archi) );
 152
 153         if (archi_table[i].long_archi==NULL) {
 154                 DEBUGADD(10,("Unknown architecture [%s] !\n", long_archi));
 155                 return NULL;
 156         }
 157
 158         /* this might be client code - but shouldn't this be an fstrcpy etc? */
 159
 160         DEBUGADD(108,("index: [%d]\n", i));
 161         DEBUGADD(108,("long architecture: [%s]\n", archi_table[i].long_archi));
 162         DEBUGADD(108,("short architecture: [%s]\n", archi_table[i].short_archi));
 163
 164         return archi_table[i].short_archi;
 165 }
 166
 167 /****************************************************************************
 168  Version information in Microsoft files is held in a VS_VERSION_INFO structure.
 169  There are two case to be covered here: PE (Portable Executable) and NE (New
 170  Executable) files. Both files support the same INFO structure, but PE files
 171  store the signature in unicode, and NE files store it as !unicode.
 172  returns -1 on error, 1 on version info found, and 0 on no version info found.
 173 ****************************************************************************/
 174
 175 static int get_file_version(files_struct *fsp, char *fname,uint32 *major, uint32 *minor)
 176 {
 177         int     i;
 178         char    *buf = NULL;
 179         ssize_t byte_count;
 180
 181         if ((buf=(char *)SMB_MALLOC(DOS_HEADER_SIZE)) == NULL) {
 182                 DEBUG(0,("get_file_version: PE file [%s] DOS Header malloc failed bytes = %d\n",
 183                                 fname, DOS_HEADER_SIZE));
 184                 goto error_exit;
 185         }
 186
 187         if ((byte_count = vfs_read_data(fsp, buf, DOS_HEADER_SIZE)) < DOS_HEADER_SIZE) {
 188                 DEBUG(3,("get_file_version: File [%s] DOS header too short, bytes read = %lu\n",
 189                          fname, (unsigned long)byte_count));
 190                 goto no_version_info;
 191         }
 192
 193         /* Is this really a DOS header? */
 194         if (SVAL(buf,DOS_HEADER_MAGIC_OFFSET) != DOS_HEADER_MAGIC) {
 195                 DEBUG(6,("get_file_version: File [%s] bad DOS magic = 0x%x\n",
 196                                 fname, SVAL(buf,DOS_HEADER_MAGIC_OFFSET)));
 197                 goto no_version_info;
 198         }
 199
 200         /* Skip OEM header (if any) and the DOS stub to start of Windows header */
 201         if (SMB_VFS_LSEEK(fsp, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
 202                 DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
 203                                 fname, errno));
 204                 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
 205                 goto no_version_info;
 206         }
 207
 208         /* Note: DOS_HEADER_SIZE and NE_HEADER_SIZE are incidentally same */
 209         if ((byte_count = vfs_read_data(fsp, buf, NE_HEADER_SIZE)) < NE_HEADER_SIZE) {
 210                 DEBUG(3,("get_file_version: File [%s] Windows header too short, bytes read = %lu\n",
 211                          fname, (unsigned long)byte_count));
 212                 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
 213                 goto no_version_info;
 214         }
 215
 216         /* The header may be a PE (Portable Executable) or an NE (New Executable) */
 217         if (IVAL(buf,PE_HEADER_SIGNATURE_OFFSET) == PE_HEADER_SIGNATURE) {
 218                 unsigned int num_sections;
 219                 unsigned int section_table_bytes;
 220
 221                 /* Just skip over optional header to get to section table */
 222                 if (SMB_VFS_LSEEK(fsp,
 223                                 SVAL(buf,PE_HEADER_OPTIONAL_HEADER_SIZE)-(NE_HEADER_SIZE-PE_HEADER_SIZE),
 224                                 SEEK_CUR) == (SMB_OFF_T)-1) {
 225                         DEBUG(3,("get_file_version: File [%s] Windows optional header too short, errno = %d\n",
 226                                 fname, errno));
 227                         goto error_exit;
 228                 }
 229
 230                 /* get the section table */
 231                 num_sections        = SVAL(buf,PE_HEADER_NUMBER_OF_SECTIONS);
 232                 section_table_bytes = num_sections * PE_HEADER_SECT_HEADER_SIZE;
 233                 if (section_table_bytes == 0)
 234                         goto error_exit;
 235
 236                 SAFE_FREE(buf);
 237                 if ((buf=(char *)SMB_MALLOC(section_table_bytes)) == NULL) {
 238                         DEBUG(0,("get_file_version: PE file [%s] section table malloc failed bytes = %d\n",
 239                                         fname, section_table_bytes));
 240                         goto error_exit;
 241                 }
 242
 243                 if ((byte_count = vfs_read_data(fsp, buf, section_table_bytes)) < section_table_bytes) {
 244                         DEBUG(3,("get_file_version: PE file [%s] Section header too short, bytes read = %lu\n",
 245                                  fname, (unsigned long)byte_count));
 246                         goto error_exit;
 247                 }
 248
 249                 /* Iterate the section table looking for the resource section ".rsrc" */
 250                 for (i = 0; i < num_sections; i++) {
 251                         int sec_offset = i * PE_HEADER_SECT_HEADER_SIZE;
 252
 253                         if (strcmp(".rsrc", &buf[sec_offset+PE_HEADER_SECT_NAME_OFFSET]) == 0) {
 254                                 unsigned int section_pos   = IVAL(buf,sec_offset+PE_HEADER_SECT_PTR_DATA_OFFSET);
 255                                 unsigned int section_bytes = IVAL(buf,sec_offset+PE_HEADER_SECT_SIZE_DATA_OFFSET);
 256
 257                                 if (section_bytes == 0)
 258                                         goto error_exit;
 259
 260                                 SAFE_FREE(buf);
 261                                 if ((buf=(char *)SMB_MALLOC(section_bytes)) == NULL) {
 262                                         DEBUG(0,("get_file_version: PE file [%s] version malloc failed bytes = %d\n",
 263                                                         fname, section_bytes));
 264                                         goto error_exit;
 265                                 }
 266
 267                                 /* Seek to the start of the .rsrc section info */
 268                                 if (SMB_VFS_LSEEK(fsp, section_pos, SEEK_SET) == (SMB_OFF_T)-1) {
 269                                         DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
 270                                                         fname, errno));
 271                                         goto error_exit;
 272                                 }
 273
 274                                 if ((byte_count = vfs_read_data(fsp, buf, section_bytes)) < section_bytes) {
 275                                         DEBUG(3,("get_file_version: PE file [%s] .rsrc section too short, bytes read = %lu\n",
 276                                                  fname, (unsigned long)byte_count));
 277                                         goto error_exit;
 278                                 }
 279
 280                                 if (section_bytes < VS_VERSION_INFO_UNICODE_SIZE)
 281                                         goto error_exit;
 282
 283                                 for (i=0; i<section_bytes-VS_VERSION_INFO_UNICODE_SIZE; i++) {
 284                                         /* Scan for 1st 3 unicoded bytes followed by word aligned magic value */
 285                                         if (buf[i] == 'V' && buf[i+1] == '\0' && buf[i+2] == 'S') {
 286                                                 /* Align to next long address */
 287                                                 int pos = (i + sizeof(VS_SIGNATURE)*2 + 3) & 0xfffffffc;
 288
 289                                                 if (IVAL(buf,pos) == VS_MAGIC_VALUE) {
 290                                                         *major = IVAL(buf,pos+VS_MAJOR_OFFSET);
 291                                                         *minor = IVAL(buf,pos+VS_MINOR_OFFSET);
 292
 293                                                         DEBUG(6,("get_file_version: PE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
 294                                                                           fname, *major, *minor,
 295                                                                           (*major>>16)&0xffff, *major&0xffff,
 296                                                                           (*minor>>16)&0xffff, *minor&0xffff));
 297                                                         SAFE_FREE(buf);
 298                                                         return 1;
 299                                                 }
 300                                         }
 301                                 }
 302                         }
 303                 }
 304
 305                 /* Version info not found, fall back to origin date/time */
 306                 DEBUG(10,("get_file_version: PE file [%s] has no version info\n", fname));
 307                 SAFE_FREE(buf);
 308                 return 0;
 309
 310         } else if (SVAL(buf,NE_HEADER_SIGNATURE_OFFSET) == NE_HEADER_SIGNATURE) {
 311                 if (CVAL(buf,NE_HEADER_TARGET_OS_OFFSET) != NE_HEADER_TARGOS_WIN ) {
 312                         DEBUG(3,("get_file_version: NE file [%s] wrong target OS = 0x%x\n",
 313                                         fname, CVAL(buf,NE_HEADER_TARGET_OS_OFFSET)));
 314                         /* At this point, we assume the file is in error. It still could be somthing
 315                          * else besides a NE file, but it unlikely at this point. */
 316                         goto error_exit;
 317                 }
 318
 319                 /* Allocate a bit more space to speed up things */
 320                 SAFE_FREE(buf);
 321                 if ((buf=(char *)SMB_MALLOC(VS_NE_BUF_SIZE)) == NULL) {
 322                         DEBUG(0,("get_file_version: NE file [%s] malloc failed bytes  = %d\n",
 323                                         fname, PE_HEADER_SIZE));
 324                         goto error_exit;
 325                 }
 326
 327                 /* This is a HACK! I got tired of trying to sort through the messy
 328                  * 'NE' file format. If anyone wants to clean this up please have at
 329                  * it, but this works. 'NE' files will eventually fade away. JRR */
 330                 while((byte_count = vfs_read_data(fsp, buf, VS_NE_BUF_SIZE)) > 0) {
 331                         /* Cover case that should not occur in a well formed 'NE' .dll file */
 332                         if (byte_count-VS_VERSION_INFO_SIZE <= 0) break;
 333
 334                         for(i=0; i<byte_count; i++) {
 335                                 /* Fast skip past data that can't possibly match */
 336                                 if (buf[i] != 'V') continue;
 337
 338                                 /* Potential match data crosses buf boundry, move it to beginning
 339                                  * of buf, and fill the buf with as much as it will hold. */
 340                                 if (i>byte_count-VS_VERSION_INFO_SIZE) {
 341                                         int bc;
 342
 343                                         memcpy(buf, &buf[i], byte_count-i);
 344                                         if ((bc = vfs_read_data(fsp, &buf[byte_count-i], VS_NE_BUF_SIZE-
 345                                                                    (byte_count-i))) < 0) {
 346
 347                                                 DEBUG(0,("get_file_version: NE file [%s] Read error, errno=%d\n",
 348                                                                  fname, errno));
 349                                                 goto error_exit;
 350                                         }
 351
 352                                         byte_count = bc + (byte_count - i);
 353                                         if (byte_count<VS_VERSION_INFO_SIZE) break;
 354
 355                                         i = 0;
 356                                 }
 357
 358                                 /* Check that the full signature string and the magic number that
 359                                  * follows exist (not a perfect solution, but the chances that this
 360                                  * occurs in code is, well, remote. Yes I know I'm comparing the 'V'
 361                                  * twice, as it is simpler to read the code. */
 362                                 if (strcmp(&buf[i], VS_SIGNATURE) == 0) {
 363                                         /* Compute skip alignment to next long address */
 364                                         int skip = -(SMB_VFS_LSEEK(fsp, 0, SEEK_CUR) - (byte_count - i) +
 365                                                                  sizeof(VS_SIGNATURE)) & 3;
 366                                         if (IVAL(buf,i+sizeof(VS_SIGNATURE)+skip) != 0xfeef04bd) continue;
 367
 368                                         *major = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MAJOR_OFFSET);
 369                                         *minor = IVAL(buf,i+sizeof(VS_SIGNATURE)+skip+VS_MINOR_OFFSET);
 370                                         DEBUG(6,("get_file_version: NE file [%s] Version = %08x:%08x (%d.%d.%d.%d)\n",
 371                                                           fname, *major, *minor,
 372                                                           (*major>>16)&0xffff, *major&0xffff,
 373                                                           (*minor>>16)&0xffff, *minor&0xffff));
 374                                         SAFE_FREE(buf);
 375                                         return 1;
 376                                 }
 377                         }
 378                 }
 379
 380                 /* Version info not found, fall back to origin date/time */
 381                 DEBUG(0,("get_file_version: NE file [%s] Version info not found\n", fname));
 382                 SAFE_FREE(buf);
 383                 return 0;
 384
 385         } else
 386                 /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
 387                 DEBUG(3,("get_file_version: File [%s] unknown file format, signature = 0x%x\n",
 388                                 fname, IVAL(buf,PE_HEADER_SIGNATURE_OFFSET)));
 389
 390         no_version_info:
 391                 SAFE_FREE(buf);
 392                 return 0;
 393
 394         error_exit:
 395                 SAFE_FREE(buf);
 396                 return -1;
 397 }
 398
 399 /****************************************************************************
 400 Drivers for Microsoft systems contain multiple files. Often, multiple drivers
 401 share one or more files. During the MS installation process files are checked
 402 to insure that only a newer version of a shared file is installed over an
 403 older version. There are several possibilities for this comparison. If there
 404 is no previous version, the new one is newer (obviously). If either file is
 405 missing the version info structure, compare the creation date (on Unix use
 406 the modification date). Otherwise chose the numerically larger version number.
 407 ****************************************************************************/
 408
 409 static int file_version_is_newer(connection_struct *conn, fstring new_file, fstring old_file)
 410 {
 411         bool use_version = true;
 412
 413         uint32 new_major;
 414         uint32 new_minor;
 415         time_t new_create_time;
 416
 417         uint32 old_major;
 418         uint32 old_minor;
 419         time_t old_create_time;
 420
 421         struct smb_filename *smb_fname = NULL;
 422         files_struct    *fsp = NULL;
 423         SMB_STRUCT_STAT st;
 424
 425         NTSTATUS status;
 426         int ret;
 427
 428         SET_STAT_INVALID(st);
 429         new_create_time = (time_t)0;
 430         old_create_time = (time_t)0;
 431
 432         /* Get file version info (if available) for previous file (if it exists) */
 433         status = driver_unix_convert(conn, old_file, &smb_fname);
 434         if (!NT_STATUS_IS_OK(status)) {
 435                 goto error_exit;
 436         }
 437
 438         status = SMB_VFS_CREATE_FILE(
 439                 conn,                                   /* conn */
 440                 NULL,                                   /* req */
 441                 0,                                      /* root_dir_fid */
 442                 smb_fname,                              /* fname */
 443                 FILE_GENERIC_READ,                      /* access_mask */
 444                 FILE_SHARE_READ | FILE_SHARE_WRITE,     /* share_access */
 445                 FILE_OPEN,                              /* create_disposition*/
 446                 0,                                      /* create_options */
 447                 FILE_ATTRIBUTE_NORMAL,                  /* file_attributes */
 448                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
 449                 0,                                      /* allocation_size */
 450                 0,                                      /* private_flags */
 451                 NULL,                                   /* sd */
 452                 NULL,                                   /* ea_list */
 453                 &fsp,                                   /* result */
 454                 NULL);                                  /* pinfo */
 455
 456         if (!NT_STATUS_IS_OK(status)) {
 457                 /* Old file not found, so by definition new file is in fact newer */
 458                 DEBUG(10,("file_version_is_newer: Can't open old file [%s], "
 459                           "errno = %d\n", smb_fname_str_dbg(smb_fname),
 460                           errno));
 461                 ret = 1;
 462                 goto done;
 463
 464         } else {
 465                 ret = get_file_version(fsp, old_file, &old_major, &old_minor);
 466                 if (ret == -1) {
 467                         goto error_exit;
 468                 }
 469
 470                 if (!ret) {
 471                         DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
 472                                          old_file));
 473                         use_version = false;
 474                         if (SMB_VFS_FSTAT(fsp, &st) == -1) {
 475                                  goto error_exit;
 476                         }
 477                         old_create_time = convert_timespec_to_time_t(st.st_ex_mtime);
 478                         DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n",
 479                                 (long)old_create_time));
 480                 }
 481         }
 482         close_file(NULL, fsp, NORMAL_CLOSE);
 483         fsp = NULL;
 484
 485         /* Get file version info (if available) for new file */
 486         status = driver_unix_convert(conn, new_file, &smb_fname);
 487         if (!NT_STATUS_IS_OK(status)) {
 488                 goto error_exit;
 489         }
 490
 491         status = SMB_VFS_CREATE_FILE(
 492                 conn,                                   /* conn */
 493                 NULL,                                   /* req */
 494                 0,                                      /* root_dir_fid */
 495                 smb_fname,                              /* fname */
 496                 FILE_GENERIC_READ,                      /* access_mask */
 497                 FILE_SHARE_READ | FILE_SHARE_WRITE,     /* share_access */
 498                 FILE_OPEN,                              /* create_disposition*/
 499                 0,                                      /* create_options */
 500                 FILE_ATTRIBUTE_NORMAL,                  /* file_attributes */
 501                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
 502                 0,                                      /* allocation_size */
 503                 0,                                      /* private_flags */
 504                 NULL,                                   /* sd */
 505                 NULL,                                   /* ea_list */
 506                 &fsp,                                   /* result */
 507                 NULL);                                  /* pinfo */
 508
 509         if (!NT_STATUS_IS_OK(status)) {
 510                 /* New file not found, this shouldn't occur if the caller did its job */
 511                 DEBUG(3,("file_version_is_newer: Can't open new file [%s], "
 512                          "errno = %d\n", smb_fname_str_dbg(smb_fname), errno));
 513                 goto error_exit;
 514
 515         } else {
 516                 ret = get_file_version(fsp, new_file, &new_major, &new_minor);
 517                 if (ret == -1) {
 518                         goto error_exit;
 519                 }
 520
 521                 if (!ret) {
 522                         DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
 523                                          new_file));
 524                         use_version = false;
 525                         if (SMB_VFS_FSTAT(fsp, &st) == -1) {
 526                                 goto error_exit;
 527                         }
 528                         new_create_time = convert_timespec_to_time_t(st.st_ex_mtime);
 529                         DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n",
 530                                 (long)new_create_time));
 531                 }
 532         }
 533         close_file(NULL, fsp, NORMAL_CLOSE);
 534         fsp = NULL;
 535
 536         if (use_version && (new_major != old_major || new_minor != old_minor)) {
 537                 /* Compare versions and choose the larger version number */
 538                 if (new_major > old_major ||
 539                         (new_major == old_major && new_minor > old_minor)) {
 540
 541                         DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
 542                         ret = 1;
 543                         goto done;
 544                 }
 545                 else {
 546                         DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
 547                         ret = 0;
 548                         goto done;
 549                 }
 550
 551         } else {
 552                 /* Compare modification time/dates and choose the newest time/date */
 553                 if (new_create_time > old_create_time) {
 554                         DEBUG(6,("file_version_is_newer: Replacing [%s] with [%s]\n", old_file, new_file));
 555                         ret = 1;
 556                         goto done;
 557                 }
 558                 else {
 559                         DEBUG(6,("file_version_is_newer: Leaving [%s] unchanged\n", old_file));
 560                         ret = 0;
 561                         goto done;
 562                 }
 563         }
 564
 565  error_exit:
 566         if(fsp)
 567                 close_file(NULL, fsp, NORMAL_CLOSE);
 568         ret = -1;
 569  done:
 570         TALLOC_FREE(smb_fname);
 571         return ret;
 572 }
 573
 574 /****************************************************************************
 575 Determine the correct cVersion associated with an architecture and driver
 576 ****************************************************************************/
 577 static uint32 get_correct_cversion(struct pipes_struct *p,
 578                                    const char *architecture,
 579                                    const char *driverpath_in,
 580                                    WERROR *perr)
 581 {
 582         int cversion = -1;
 583         NTSTATUS          nt_status;
 584         struct smb_filename *smb_fname = NULL;
 585         char *driverpath = NULL;
 586         files_struct      *fsp = NULL;
 587         connection_struct *conn = NULL;
 588         char *oldcwd;
 589         char *printdollar = NULL;
 590         int printdollar_snum;
 591
 592         *perr = WERR_INVALID_PARAM;
 593
 594         /* If architecture is Windows 95/98/ME, the version is always 0. */
 595         if (strcmp(architecture, SPL_ARCH_WIN40) == 0) {
 596                 DEBUG(10,("get_correct_cversion: Driver is Win9x, cversion = 0\n"));
 597                 *perr = WERR_OK;
 598                 return 0;
 599         }
 600
 601         /* If architecture is Windows x64, the version is always 3. */
 602         if (strcmp(architecture, SPL_ARCH_X64) == 0) {
 603                 DEBUG(10,("get_correct_cversion: Driver is x64, cversion = 3\n"));
 604                 *perr = WERR_OK;
 605                 return 3;
 606         }
 607
 608         printdollar_snum = find_service(talloc_tos(), "print$", &printdollar);
 609         if (!printdollar) {
 610                 *perr = WERR_NOMEM;
 611                 return -1;
 612         }
 613         if (printdollar_snum == -1) {
 614                 *perr = WERR_NO_SUCH_SHARE;
 615                 return -1;
 616         }
 617
 618         nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
 619                                        lp_pathname(printdollar_snum),
 620                                        p->session_info, &oldcwd);
 621         if (!NT_STATUS_IS_OK(nt_status)) {
 622                 DEBUG(0,("get_correct_cversion: create_conn_struct "
 623                          "returned %s\n", nt_errstr(nt_status)));
 624                 *perr = ntstatus_to_werror(nt_status);
 625                 return -1;
 626         }
 627
 628         nt_status = set_conn_force_user_group(conn, printdollar_snum);
 629         if (!NT_STATUS_IS_OK(nt_status)) {
 630                 DEBUG(0, ("failed set force user / group\n"));
 631                 *perr = ntstatus_to_werror(nt_status);
 632                 goto error_free_conn;
 633         }
 634
 635         if (!become_user(conn, get_current_vuid(conn))) {
 636                 DEBUG(0, ("failed to become user\n"));
 637                 *perr = WERR_ACCESS_DENIED;
 638                 goto error_free_conn;
 639         }
 640
 641         /* Open the driver file (Portable Executable format) and determine the
 642          * deriver the cversion. */
 643         driverpath = talloc_asprintf(talloc_tos(),
 644                                         "%s/%s",
 645                                         architecture,
 646                                         driverpath_in);
 647         if (!driverpath) {
 648                 *perr = WERR_NOMEM;
 649                 goto error_exit;
 650         }
 651
 652         nt_status = driver_unix_convert(conn, driverpath, &smb_fname);
 653         if (!NT_STATUS_IS_OK(nt_status)) {
 654                 *perr = ntstatus_to_werror(nt_status);
 655                 goto error_exit;
 656         }
 657
 658         nt_status = vfs_file_exist(conn, smb_fname);
 659         if (!NT_STATUS_IS_OK(nt_status)) {
 660                 DEBUG(3,("get_correct_cversion: vfs_file_exist failed\n"));
 661                 *perr = WERR_BADFILE;
 662                 goto error_exit;
 663         }
 664
 665         nt_status = SMB_VFS_CREATE_FILE(
 666                 conn,                                   /* conn */
 667                 NULL,                                   /* req */
 668                 0,                                      /* root_dir_fid */
 669                 smb_fname,                              /* fname */
 670                 FILE_GENERIC_READ,                      /* access_mask */
 671                 FILE_SHARE_READ | FILE_SHARE_WRITE,     /* share_access */
 672                 FILE_OPEN,                              /* create_disposition*/
 673                 0,                                      /* create_options */
 674                 FILE_ATTRIBUTE_NORMAL,                  /* file_attributes */
 675                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
 676                 0,                                      /* private_flags */
 677                 0,                                      /* allocation_size */
 678                 NULL,                                   /* sd */
 679                 NULL,                                   /* ea_list */
 680                 &fsp,                                   /* result */
 681                 NULL);                                  /* pinfo */
 682
 683         if (!NT_STATUS_IS_OK(nt_status)) {
 684                 DEBUG(3,("get_correct_cversion: Can't open file [%s], errno = "
 685                          "%d\n", smb_fname_str_dbg(smb_fname), errno));
 686                 *perr = WERR_ACCESS_DENIED;
 687                 goto error_exit;
 688         } else {
 689                 uint32 major;
 690                 uint32 minor;
 691                 int    ret;
 692
 693                 ret = get_file_version(fsp, smb_fname->base_name, &major, &minor);
 694                 if (ret == -1) {
 695                         *perr = WERR_INVALID_PARAM;
 696                         goto error_exit;
 697                 } else if (!ret) {
 698                         DEBUG(6,("get_correct_cversion: Version info not "
 699                                  "found [%s]\n",
 700                                  smb_fname_str_dbg(smb_fname)));
 701                         *perr = WERR_INVALID_PARAM;
 702                         goto error_exit;
 703                 }
 704
 705                 /*
 706                  * This is a Microsoft'ism. See references in MSDN to VER_FILEVERSION
 707                  * for more details. Version in this case is not just the version of the
 708                  * file, but the version in the sense of kernal mode (2) vs. user mode
 709                  * (3) drivers. Other bits of the version fields are the version info.
 710                  * JRR 010716
 711                 */
 712                 cversion = major & 0x0000ffff;
 713                 switch (cversion) {
 714                         case 2: /* WinNT drivers */
 715                         case 3: /* Win2K drivers */
 716                                 break;
 717
 718                         default:
 719                                 DEBUG(6,("get_correct_cversion: cversion "
 720                                          "invalid [%s]  cversion = %d\n",
 721                                          smb_fname_str_dbg(smb_fname),
 722                                          cversion));
 723                                 goto error_exit;
 724                 }
 725
 726                 DEBUG(10,("get_correct_cversion: Version info found [%s] major"
 727                           " = 0x%x  minor = 0x%x\n",
 728                           smb_fname_str_dbg(smb_fname), major, minor));
 729         }
 730
 731         DEBUG(10,("get_correct_cversion: Driver file [%s] cversion = %d\n",
 732                   smb_fname_str_dbg(smb_fname), cversion));
 733         *perr = WERR_OK;
 734
 735  error_exit:
 736         unbecome_user();
 737  error_free_conn:
 738         TALLOC_FREE(smb_fname);
 739         if (fsp != NULL) {
 740                 close_file(NULL, fsp, NORMAL_CLOSE);
 741         }
 742         if (conn != NULL) {
 743                 vfs_ChDir(conn, oldcwd);
 744                 SMB_VFS_DISCONNECT(conn);
 745                 conn_free(conn);
 746         }
 747         if (!NT_STATUS_IS_OK(*perr)) {
 748                 cversion = -1;
 749         }
 750
 751         return cversion;
 752 }
 753
 754 /****************************************************************************
 755 ****************************************************************************/
 756
 757 #define strip_driver_path(_mem_ctx, _element) do { \
 758         if (_element && ((_p = strrchr((_element), '\\')) != NULL)) { \
 759                 (_element) = talloc_asprintf((_mem_ctx), "%s", _p+1); \
 760                 W_ERROR_HAVE_NO_MEMORY((_element)); \
 761         } \
 762 } while (0);
 763
 764 static WERROR clean_up_driver_struct_level(TALLOC_CTX *mem_ctx,
 765                                            struct pipes_struct *rpc_pipe,
 766                                            const char *architecture,
 767                                            const char **driver_path,
 768                                            const char **data_file,
 769                                            const char **config_file,
 770                                            const char **help_file,
 771                                            struct spoolss_StringArray *dependent_files,
 772                                            enum spoolss_DriverOSVersion *version)
 773 {
 774         const char *short_architecture;
 775         int i;
 776         WERROR err;
 777         char *_p;
 778
 779         if (!*driver_path || !*data_file) {
 780                 return WERR_INVALID_PARAM;
 781         }
 782
 783         if (!strequal(architecture, SPOOLSS_ARCHITECTURE_4_0) && !*config_file) {
 784                 return WERR_INVALID_PARAM;
 785         }
 786
 787         /* clean up the driver name.
 788          * we can get .\driver.dll
 789          * or worse c:\windows\system\driver.dll !
 790          */
 791         /* using an intermediate string to not have overlaping memcpy()'s */
 792
 793         strip_driver_path(mem_ctx, *driver_path);
 794         strip_driver_path(mem_ctx, *data_file);
 795         if (*config_file) {
 796                 strip_driver_path(mem_ctx, *config_file);
 797         }
 798         if (help_file) {
 799                 strip_driver_path(mem_ctx, *help_file);
 800         }
 801
 802         if (dependent_files && dependent_files->string) {
 803                 for (i=0; dependent_files->string[i]; i++) {
 804                         strip_driver_path(mem_ctx, dependent_files->string[i]);
 805                 }
 806         }
 807
 808         short_architecture = get_short_archi(architecture);
 809         if (!short_architecture) {
 810                 return WERR_UNKNOWN_PRINTER_DRIVER;
 811         }
 812
 813         /* jfm:7/16/2000 the client always sends the cversion=0.
 814          * The server should check which version the driver is by reading
 815          * the PE header of driver->driverpath.
 816          *
 817          * For Windows 95/98 the version is 0 (so the value sent is correct)
 818          * For Windows NT (the architecture doesn't matter)
 819          *      NT 3.1: cversion=0
 820          *      NT 3.5/3.51: cversion=1
 821          *      NT 4: cversion=2
 822          *      NT2K: cversion=3
 823          */
 824
 825         *version = get_correct_cversion(rpc_pipe, short_architecture,
 826                                         *driver_path, &err);
 827         if (*version == -1) {
 828                 return err;
 829         }
 830
 831         return WERR_OK;
 832 }
 833
 834 /****************************************************************************
 835 ****************************************************************************/
 836
 837 WERROR clean_up_driver_struct(TALLOC_CTX *mem_ctx,
 838                               struct pipes_struct *rpc_pipe,
 839                               struct spoolss_AddDriverInfoCtr *r)
 840 {
 841         switch (r->level) {
 842         case 3:
 843                 return clean_up_driver_struct_level(mem_ctx, rpc_pipe,
 844                                                     r->info.info3->architecture,
 845                                                     &r->info.info3->driver_path,
 846                                                     &r->info.info3->data_file,
 847                                                     &r->info.info3->config_file,
 848                                                     &r->info.info3->help_file,
 849                                                     r->info.info3->dependent_files,
 850                                                     &r->info.info3->version);
 851         case 6:
 852                 return clean_up_driver_struct_level(mem_ctx, rpc_pipe,
 853                                                     r->info.info6->architecture,
 854                                                     &r->info.info6->driver_path,
 855                                                     &r->info.info6->data_file,
 856                                                     &r->info.info6->config_file,
 857                                                     &r->info.info6->help_file,
 858                                                     r->info.info6->dependent_files,
 859                                                     &r->info.info6->version);
 860         default:
 861                 return WERR_NOT_SUPPORTED;
 862         }
 863 }
 864
 865 /****************************************************************************
 866  This function sucks and should be replaced. JRA.
 867 ****************************************************************************/
 868
 869 static void convert_level_6_to_level3(struct spoolss_AddDriverInfo3 *dst,
 870                                       const struct spoolss_AddDriverInfo6 *src)
 871 {
 872         dst->version            = src->version;
 873
 874         dst->driver_name        = src->driver_name;
 875         dst->architecture       = src->architecture;
 876         dst->driver_path        = src->driver_path;
 877         dst->data_file          = src->data_file;
 878         dst->config_file        = src->config_file;
 879         dst->help_file          = src->help_file;
 880         dst->monitor_name       = src->monitor_name;
 881         dst->default_datatype   = src->default_datatype;
 882         dst->_ndr_size_dependent_files = src->_ndr_size_dependent_files;
 883         dst->dependent_files    = src->dependent_files;
 884 }
 885
 886 /****************************************************************************
 887 ****************************************************************************/
 888
 889 static WERROR move_driver_file_to_download_area(TALLOC_CTX *mem_ctx,
 890                                                 connection_struct *conn,
 891                                                 const char *driver_file,
 892                                                 const char *short_architecture,
 893                                                 uint32_t driver_version,
 894                                                 uint32_t version)
 895 {
 896         struct smb_filename *smb_fname_old = NULL;
 897         struct smb_filename *smb_fname_new = NULL;
 898         char *old_name = NULL;
 899         char *new_name = NULL;
 900         NTSTATUS status;
 901         WERROR ret;
 902
 903         old_name = talloc_asprintf(mem_ctx, "%s/%s",
 904                                    short_architecture, driver_file);
 905         W_ERROR_HAVE_NO_MEMORY(old_name);
 906
 907         new_name = talloc_asprintf(mem_ctx, "%s/%d/%s",
 908                                    short_architecture, driver_version, driver_file);
 909         if (new_name == NULL) {
 910                 TALLOC_FREE(old_name);
 911                 return WERR_NOMEM;
 912         }
 913
 914         if (version != -1 && (version = file_version_is_newer(conn, old_name, new_name)) > 0) {
 915
 916                 status = driver_unix_convert(conn, old_name, &smb_fname_old);
 917                 if (!NT_STATUS_IS_OK(status)) {
 918                         ret = WERR_NOMEM;
 919                         goto out;
 920                 }
 921
 922                 /* Setup a synthetic smb_filename struct */
 923                 smb_fname_new = TALLOC_ZERO_P(mem_ctx, struct smb_filename);
 924                 if (!smb_fname_new) {
 925                         ret = WERR_NOMEM;
 926                         goto out;
 927                 }
 928
 929                 smb_fname_new->base_name = new_name;
 930
 931                 DEBUG(10,("move_driver_file_to_download_area: copying '%s' to "
 932                           "'%s'\n", smb_fname_old->base_name,
 933                           smb_fname_new->base_name));
 934
 935                 status = copy_file(mem_ctx, conn, smb_fname_old, smb_fname_new,
 936                                    OPENX_FILE_EXISTS_TRUNCATE |
 937                                    OPENX_FILE_CREATE_IF_NOT_EXIST,
 938                                    0, false);
 939
 940                 if (!NT_STATUS_IS_OK(status)) {
 941                         DEBUG(0,("move_driver_file_to_download_area: Unable "
 942                                  "to rename [%s] to [%s]: %s\n",
 943                                  smb_fname_old->base_name, new_name,
 944                                  nt_errstr(status)));
 945                         ret = WERR_ACCESS_DENIED;
 946                         goto out;
 947                 }
 948         }
 949
 950         ret = WERR_OK;
 951  out:
 952         TALLOC_FREE(smb_fname_old);
 953         TALLOC_FREE(smb_fname_new);
 954         return ret;
 955 }
 956
 957 WERROR move_driver_to_download_area(struct pipes_struct *p,
 958                                     struct spoolss_AddDriverInfoCtr *r)
 959 {
 960         struct spoolss_AddDriverInfo3 *driver;
 961         struct spoolss_AddDriverInfo3 converted_driver;
 962         const char *short_architecture;
 963         struct smb_filename *smb_dname = NULL;
 964         char *new_dir = NULL;
 965         connection_struct *conn = NULL;
 966         NTSTATUS nt_status;
 967         int i;
 968         TALLOC_CTX *ctx = talloc_tos();
 969         int ver = 0;
 970         char *oldcwd;
 971         char *printdollar = NULL;
 972         int printdollar_snum;
 973         WERROR err = WERR_OK;
 974
 975         switch (r->level) {
 976         case 3:
 977                 driver = r->info.info3;
 978                 break;
 979         case 6:
 980                 convert_level_6_to_level3(&converted_driver, r->info.info6);
 981                 driver = &converted_driver;
 982                 break;
 983         default:
 984                 DEBUG(0,("move_driver_to_download_area: Unknown info level (%u)\n", (unsigned int)r->level));
 985                 return WERR_UNKNOWN_LEVEL;
 986         }
 987
 988         short_architecture = get_short_archi(driver->architecture);
 989         if (!short_architecture) {
 990                 return WERR_UNKNOWN_PRINTER_DRIVER;
 991         }
 992
 993         printdollar_snum = find_service(ctx, "print$", &printdollar);
 994         if (!printdollar) {
 995                 return WERR_NOMEM;
 996         }
 997         if (printdollar_snum == -1) {
 998                 return WERR_NO_SUCH_SHARE;
 999         }
1000
1001         nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
1002                                        lp_pathname(printdollar_snum),
1003                                        p->session_info, &oldcwd);
1004         if (!NT_STATUS_IS_OK(nt_status)) {
1005                 DEBUG(0,("move_driver_to_download_area: create_conn_struct "
1006                          "returned %s\n", nt_errstr(nt_status)));
1007                 err = ntstatus_to_werror(nt_status);
1008                 return err;
1009         }
1010
1011         nt_status = set_conn_force_user_group(conn, printdollar_snum);
1012         if (!NT_STATUS_IS_OK(nt_status)) {
1013                 DEBUG(0, ("failed set force user / group\n"));
1014                 err = ntstatus_to_werror(nt_status);
1015                 goto err_free_conn;
1016         }
1017
1018         if (!become_user(conn, get_current_vuid(conn))) {
1019                 DEBUG(0, ("failed to become user\n"));
1020                 err = WERR_ACCESS_DENIED;
1021                 goto err_free_conn;
1022         }
1023
1024         new_dir = talloc_asprintf(ctx,
1025                                 "%s/%d",
1026                                 short_architecture,
1027                                 driver->version);
1028         if (!new_dir) {
1029                 err = WERR_NOMEM;
1030                 goto err_exit;
1031         }
1032         nt_status = driver_unix_convert(conn, new_dir, &smb_dname);
1033         if (!NT_STATUS_IS_OK(nt_status)) {
1034                 err = WERR_NOMEM;
1035                 goto err_exit;
1036         }
1037
1038         DEBUG(5,("Creating first directory: %s\n", smb_dname->base_name));
1039
1040         nt_status = create_directory(conn, NULL, smb_dname);
1041         if (!NT_STATUS_IS_OK(nt_status)
1042          && !NT_STATUS_EQUAL(nt_status, NT_STATUS_OBJECT_NAME_COLLISION)) {
1043                 DEBUG(0, ("failed to create driver destination directory: %s\n",
1044                           nt_errstr(nt_status)));
1045                 err = ntstatus_to_werror(nt_status);
1046                 goto err_exit;
1047         }
1048
1049         /* For each driver file, archi\filexxx.yyy, if there is a duplicate file
1050          * listed for this driver which has already been moved, skip it (note:
1051          * drivers may list the same file name several times. Then check if the
1052          * file already exists in archi\version\, if so, check that the version
1053          * info (or time stamps if version info is unavailable) is newer (or the
1054          * date is later). If it is, move it to archi\version\filexxx.yyy.
1055          * Otherwise, delete the file.
1056          *
1057          * If a file is not moved to archi\version\ because of an error, all the
1058          * rest of the 'unmoved' driver files are removed from archi\. If one or
1059          * more of the driver's files was already moved to archi\version\, it
1060          * potentially leaves the driver in a partially updated state. Version
1061          * trauma will most likely occur if an client attempts to use any printer
1062          * bound to the driver. Perhaps a rewrite to make sure the moves can be
1063          * done is appropriate... later JRR
1064          */
1065
1066         DEBUG(5,("Moving files now !\n"));
1067
1068         if (driver->driver_path && strlen(driver->driver_path)) {
1069
1070                 err = move_driver_file_to_download_area(ctx,
1071                                                         conn,
1072                                                         driver->driver_path,
1073                                                         short_architecture,
1074                                                         driver->version,
1075                                                         ver);
1076                 if (!W_ERROR_IS_OK(err)) {
1077                         goto err_exit;
1078                 }
1079         }
1080
1081         if (driver->data_file && strlen(driver->data_file)) {
1082                 if (!strequal(driver->data_file, driver->driver_path)) {
1083
1084                         err = move_driver_file_to_download_area(ctx,
1085                                                                 conn,
1086                                                                 driver->data_file,
1087                                                                 short_architecture,
1088                                                                 driver->version,
1089                                                                 ver);
1090                         if (!W_ERROR_IS_OK(err)) {
1091                                 goto err_exit;
1092                         }
1093                 }
1094         }
1095
1096         if (driver->config_file && strlen(driver->config_file)) {
1097                 if (!strequal(driver->config_file, driver->driver_path) &&
1098                     !strequal(driver->config_file, driver->data_file)) {
1099
1100                         err = move_driver_file_to_download_area(ctx,
1101                                                                 conn,
1102                                                                 driver->config_file,
1103                                                                 short_architecture,
1104                                                                 driver->version,
1105                                                                 ver);
1106                         if (!W_ERROR_IS_OK(err)) {
1107                                 goto err_exit;
1108                         }
1109                 }
1110         }
1111
1112         if (driver->help_file && strlen(driver->help_file)) {
1113                 if (!strequal(driver->help_file, driver->driver_path) &&
1114                     !strequal(driver->help_file, driver->data_file) &&
1115                     !strequal(driver->help_file, driver->config_file)) {
1116
1117                         err = move_driver_file_to_download_area(ctx,
1118                                                                 conn,
1119                                                                 driver->help_file,
1120                                                                 short_architecture,
1121                                                                 driver->version,
1122                                                                 ver);
1123                         if (!W_ERROR_IS_OK(err)) {
1124                                 goto err_exit;
1125                         }
1126                 }
1127         }
1128
1129         if (driver->dependent_files && driver->dependent_files->string) {
1130                 for (i=0; driver->dependent_files->string[i]; i++) {
1131                         if (!strequal(driver->dependent_files->string[i], driver->driver_path) &&
1132                             !strequal(driver->dependent_files->string[i], driver->data_file) &&
1133                             !strequal(driver->dependent_files->string[i], driver->config_file) &&
1134                             !strequal(driver->dependent_files->string[i], driver->help_file)) {
1135                                 int j;
1136                                 for (j=0; j < i; j++) {
1137                                         if (strequal(driver->dependent_files->string[i], driver->dependent_files->string[j])) {
1138                                                 goto NextDriver;
1139                                         }
1140                                 }
1141
1142                                 err = move_driver_file_to_download_area(ctx,
1143                                                                         conn,
1144                                                                         driver->dependent_files->string[i],
1145                                                                         short_architecture,
1146                                                                         driver->version,
1147                                                                         ver);
1148                                 if (!W_ERROR_IS_OK(err)) {
1149                                         goto err_exit;
1150                                 }
1151                         }
1152                 NextDriver: ;
1153                 }
1154         }
1155
1156         err = WERR_OK;
1157  err_exit:
1158         unbecome_user();
1159  err_free_conn:
1160         TALLOC_FREE(smb_dname);
1161
1162         if (conn != NULL) {
1163                 vfs_ChDir(conn, oldcwd);
1164                 SMB_VFS_DISCONNECT(conn);
1165                 conn_free(conn);
1166         }
1167
1168         return err;
1169 }
1170
1171 /****************************************************************************
1172  Create and allocate a default devicemode.
1173 ****************************************************************************/
1174
1175 WERROR spoolss_create_default_devmode(TALLOC_CTX *mem_ctx,
1176                                       const char *devicename,
1177                                       struct spoolss_DeviceMode **devmode)
1178 {
1179         struct spoolss_DeviceMode *dm;
1180         char *dname;
1181
1182         dm = talloc_zero(mem_ctx, struct spoolss_DeviceMode);
1183         if (dm == NULL) {
1184                 return WERR_NOMEM;
1185         }
1186
1187         dname = talloc_asprintf(dm, "%s", devicename);
1188         if (dname == NULL) {
1189                 return WERR_NOMEM;
1190         }
1191         if (strlen(dname) > MAXDEVICENAME) {
1192                 dname[MAXDEVICENAME] = '\0';
1193         }
1194         dm->devicename = dname;
1195
1196         dm->formname = talloc_strdup(dm, "Letter");
1197         if (dm->formname == NULL) {
1198                 return WERR_NOMEM;
1199         }
1200
1201         dm->specversion          = DMSPEC_NT4_AND_ABOVE;
1202         dm->driverversion        = 0x0400;
1203         dm->size                 = 0x00DC;
1204         dm->__driverextra_length = 0;
1205         dm->fields               = DEVMODE_FORMNAME |
1206                                    DEVMODE_TTOPTION |
1207                                    DEVMODE_PRINTQUALITY |
1208                                    DEVMODE_DEFAULTSOURCE |
1209                                    DEVMODE_COPIES |
1210                                    DEVMODE_SCALE |
1211                                    DEVMODE_PAPERSIZE |
1212                                    DEVMODE_ORIENTATION;
1213         dm->orientation          = DMORIENT_PORTRAIT;
1214         dm->papersize            = DMPAPER_LETTER;
1215         dm->paperlength          = 0;
1216         dm->paperwidth           = 0;
1217         dm->scale                = 0x64;
1218         dm->copies               = 1;
1219         dm->defaultsource        = DMBIN_FORMSOURCE;
1220         dm->printquality         = DMRES_HIGH;           /* 0x0258 */
1221         dm->color                = DMRES_MONOCHROME;
1222         dm->duplex               = DMDUP_SIMPLEX;
1223         dm->yresolution          = 0;
1224         dm->ttoption             = DMTT_SUBDEV;
1225         dm->collate              = DMCOLLATE_FALSE;
1226         dm->icmmethod            = 0;
1227         dm->icmintent            = 0;
1228         dm->mediatype            = 0;
1229         dm->dithertype           = 0;
1230
1231         dm->logpixels            = 0;
1232         dm->bitsperpel           = 0;
1233         dm->pelswidth            = 0;
1234         dm->pelsheight           = 0;
1235         dm->displayflags         = 0;
1236         dm->displayfrequency     = 0;
1237         dm->reserved1            = 0;
1238         dm->reserved2            = 0;
1239         dm->panningwidth         = 0;
1240         dm->panningheight        = 0;
1241
1242         dm->driverextra_data.data = NULL;
1243         dm->driverextra_data.length = 0;
1244
1245         *devmode = dm;
1246         return WERR_OK;
1247 }
1248
1249 WERROR spoolss_create_default_secdesc(TALLOC_CTX *mem_ctx,
1250                                       struct spoolss_security_descriptor **secdesc)
1251 {
1252         struct security_ace ace[7];     /* max number of ace entries */
1253         int i = 0;
1254         uint32_t sa;
1255         struct security_acl *psa = NULL;
1256         struct security_descriptor *psd = NULL;
1257         struct dom_sid adm_sid;
1258         size_t sd_size;
1259
1260         /* Create an ACE where Everyone is allowed to print */
1261
1262         sa = PRINTER_ACE_PRINT;
1263         init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
1264                      sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
1265
1266         /* Add the domain admins group if we are a DC */
1267
1268         if ( IS_DC ) {
1269                 struct dom_sid domadmins_sid;
1270
1271                 sid_compose(&domadmins_sid, get_global_sam_sid(),
1272                             DOMAIN_RID_ADMINS);
1273
1274                 sa = PRINTER_ACE_FULL_CONTROL;
1275                 init_sec_ace(&ace[i++], &domadmins_sid,
1276                         SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
1277                         SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
1278                 init_sec_ace(&ace[i++], &domadmins_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
1279                         sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
1280         }
1281         else if (secrets_fetch_domain_sid(lp_workgroup(), &adm_sid)) {
1282                 sid_append_rid(&adm_sid, DOMAIN_RID_ADMINISTRATOR);
1283
1284                 sa = PRINTER_ACE_FULL_CONTROL;
1285                 init_sec_ace(&ace[i++], &adm_sid,
1286                         SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
1287                         SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
1288                 init_sec_ace(&ace[i++], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
1289                         sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
1290         }
1291
1292         /* add BUILTIN\Administrators as FULL CONTROL */
1293
1294         sa = PRINTER_ACE_FULL_CONTROL;
1295         init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
1296                 SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
1297                 SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
1298         init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
1299                 SEC_ACE_TYPE_ACCESS_ALLOWED,
1300                 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
1301
1302         /* add BUILTIN\Print Operators as FULL CONTROL */
1303
1304         sa = PRINTER_ACE_FULL_CONTROL;
1305         init_sec_ace(&ace[i++], &global_sid_Builtin_Print_Operators,
1306                 SEC_ACE_TYPE_ACCESS_ALLOWED, sa,
1307                 SEC_ACE_FLAG_OBJECT_INHERIT | SEC_ACE_FLAG_INHERIT_ONLY);
1308         init_sec_ace(&ace[i++], &global_sid_Builtin_Print_Operators,
1309                 SEC_ACE_TYPE_ACCESS_ALLOWED,
1310                 sa, SEC_ACE_FLAG_CONTAINER_INHERIT);
1311
1312         /* Make the security descriptor owned by the BUILTIN\Administrators */
1313
1314         /* The ACL revision number in rpc_secdesc.h differs from the one
1315            created by NT when setting ACE entries in printer
1316            descriptors.  NT4 complains about the property being edited by a
1317            NT5 machine. */
1318
1319         if ((psa = make_sec_acl(mem_ctx, NT4_ACL_REVISION, i, ace)) != NULL) {
1320                 psd = make_sec_desc(mem_ctx,
1321                                     SD_REVISION,
1322                                     SEC_DESC_SELF_RELATIVE,
1323                                     &global_sid_Builtin_Administrators,
1324                                     &global_sid_Builtin_Administrators,
1325                                     NULL,
1326                                     psa,
1327                                     &sd_size);
1328         }
1329
1330         if (psd == NULL) {
1331                 DEBUG(0,("construct_default_printer_sd: Failed to make SEC_DESC.\n"));
1332                 return WERR_NOMEM;
1333         }
1334
1335         DEBUG(4,("construct_default_printer_sdb: size = %u.\n",
1336                  (unsigned int)sd_size));
1337
1338         *secdesc = psd;
1339
1340         return WERR_OK;
1341 }
1342
1343 /****************************************************************************
1344  ***************************************************************************/
1345
1346 static char *win_driver;
1347 static char *os2_driver;
1348
1349 static const char *get_win_driver(void)
1350 {
1351         if (win_driver == NULL) {
1352                 return "";
1353         }
1354         return win_driver;
1355 }
1356
1357 static const char *get_os2_driver(void)
1358 {
1359         if (os2_driver == NULL) {
1360                 return "";
1361         }
1362         return os2_driver;
1363 }
1364
1365 static bool set_driver_mapping(const char *from, const char *to)
1366 {
1367         SAFE_FREE(win_driver);
1368         SAFE_FREE(os2_driver);
1369
1370         win_driver = SMB_STRDUP(from);
1371         os2_driver = SMB_STRDUP(to);
1372
1373         if (win_driver == NULL || os2_driver == NULL) {
1374                 SAFE_FREE(win_driver);
1375                 SAFE_FREE(os2_driver);
1376                 return false;
1377         }
1378         return true;
1379 }
1380
1381 /**
1382  * @internal
1383  *
1384  * @brief Map a Windows driver to a OS/2 driver.
1385  *
1386  * @param[in]  mem_ctx  The memory context to use.
1387  *
1388  * @param[in,out] pdrivername The drivername of Windows to remap.
1389  *
1390  * @return              WERR_OK on success, a corresponding WERROR on failure.
1391  */
1392 WERROR spoolss_map_to_os2_driver(TALLOC_CTX *mem_ctx, const char **pdrivername)
1393 {
1394         const char *mapfile = lp_os2_driver_map();
1395         char **lines = NULL;
1396         const char *drivername;
1397         int numlines = 0;
1398         int i;
1399
1400         if (pdrivername == NULL || *pdrivername == NULL || *pdrivername[0] == '\0') {
1401                 return WERR_INVALID_PARAMETER;
1402         }
1403
1404         drivername = *pdrivername;
1405
1406         if (mapfile[0] == '\0') {
1407                 return WERR_BADFILE;
1408         }
1409
1410         if (strequal(drivername, get_win_driver())) {
1411                 DEBUG(3,("Mapped Windows driver %s to OS/2 driver %s\n",
1412                         drivername, get_os2_driver()));
1413                 drivername = talloc_strdup(mem_ctx, get_os2_driver());
1414                 if (drivername == NULL) {
1415                         return WERR_NOMEM;
1416                 }
1417                 *pdrivername = drivername;
1418                 return WERR_OK;
1419         }
1420
1421         lines = file_lines_load(mapfile, &numlines, 0, NULL);
1422         if (numlines == 0 || lines == NULL) {
1423                 DEBUG(0,("No entries in OS/2 driver map %s\n", mapfile));
1424                 TALLOC_FREE(lines);
1425                 return WERR_EMPTY;
1426         }
1427
1428         DEBUG(4,("Scanning OS/2 driver map %s\n",mapfile));
1429
1430         for( i = 0; i < numlines; i++) {
1431                 char *nt_name = lines[i];
1432                 char *os2_name = strchr(nt_name, '=');
1433
1434                 if (os2_name == NULL) {
1435                         continue;
1436                 }
1437
1438                 *os2_name++ = '\0';
1439
1440                 while (isspace(*nt_name)) {
1441                         nt_name++;
1442                 }
1443
1444                 if (*nt_name == '\0' || strchr("#;", *nt_name)) {
1445                         continue;
1446                 }
1447
1448                 {
1449                         int l = strlen(nt_name);
1450                         while (l && isspace(nt_name[l - 1])) {
1451                                 nt_name[l - 1] = 0;
1452                                 l--;
1453                         }
1454                 }
1455
1456                 while (isspace(*os2_name)) {
1457                         os2_name++;
1458                 }
1459
1460                 {
1461                         int l = strlen(os2_name);
1462                         while (l && isspace(os2_name[l-1])) {
1463                                 os2_name[l-1] = 0;
1464                                 l--;
1465                         }
1466                 }
1467
1468                 if (strequal(nt_name, drivername)) {
1469                         DEBUG(3,("Mapped Windows driver %s to OS/2 driver %s\n",drivername,os2_name));
1470                         set_driver_mapping(drivername, os2_name);
1471                         drivername = talloc_strdup(mem_ctx, os2_name);
1472                         TALLOC_FREE(lines);
1473                         if (drivername == NULL) {
1474                                 return WERR_NOMEM;
1475                         }
1476                         *pdrivername = drivername;
1477                         return WERR_OK;
1478                 }
1479         }
1480
1481         TALLOC_FREE(lines);
1482         return WERR_OK;
1483 }
1484
1485 /****************************************************************************
1486 ****************************************************************************/
1487
1488 bool driver_info_ctr_to_info8(struct spoolss_AddDriverInfoCtr *r,
1489                               struct spoolss_DriverInfo8 *_info8)
1490 {
1491         struct spoolss_DriverInfo8 info8;
1492
1493         ZERO_STRUCT(info8);
1494
1495         switch (r->level) {
1496         case 3:
1497                 info8.version           = r->info.info3->version;
1498                 info8.driver_name       = r->info.info3->driver_name;
1499                 info8.architecture      = r->info.info3->architecture;
1500                 info8.driver_path       = r->info.info3->driver_path;
1501                 info8.data_file         = r->info.info3->data_file;
1502                 info8.config_file       = r->info.info3->config_file;
1503                 info8.help_file         = r->info.info3->help_file;
1504                 info8.monitor_name      = r->info.info3->monitor_name;
1505                 info8.default_datatype  = r->info.info3->default_datatype;
1506                 if (r->info.info3->dependent_files && r->info.info3->dependent_files->string) {
1507                         info8.dependent_files   = r->info.info3->dependent_files->string;
1508                 }
1509                 break;
1510         case 6:
1511                 info8.version           = r->info.info6->version;
1512                 info8.driver_name       = r->info.info6->driver_name;
1513                 info8.architecture      = r->info.info6->architecture;
1514                 info8.driver_path       = r->info.info6->driver_path;
1515                 info8.data_file         = r->info.info6->data_file;
1516                 info8.config_file       = r->info.info6->config_file;
1517                 info8.help_file         = r->info.info6->help_file;
1518                 info8.monitor_name      = r->info.info6->monitor_name;
1519                 info8.default_datatype  = r->info.info6->default_datatype;
1520                 if (r->info.info6->dependent_files && r->info.info6->dependent_files->string) {
1521                         info8.dependent_files   = r->info.info6->dependent_files->string;
1522                 }
1523                 info8.driver_date       = r->info.info6->driver_date;
1524                 info8.driver_version    = r->info.info6->driver_version;
1525                 info8.manufacturer_name = r->info.info6->manufacturer_name;
1526                 info8.manufacturer_url  = r->info.info6->manufacturer_url;
1527                 info8.hardware_id       = r->info.info6->hardware_id;
1528                 info8.provider          = r->info.info6->provider;
1529                 break;
1530         case 8:
1531                 info8.version           = r->info.info8->version;
1532                 info8.driver_name       = r->info.info8->driver_name;
1533                 info8.architecture      = r->info.info8->architecture;
1534                 info8.driver_path       = r->info.info8->driver_path;
1535                 info8.data_file         = r->info.info8->data_file;
1536                 info8.config_file       = r->info.info8->config_file;
1537                 info8.help_file         = r->info.info8->help_file;
1538                 info8.monitor_name      = r->info.info8->monitor_name;
1539                 info8.default_datatype  = r->info.info8->default_datatype;
1540                 if (r->info.info8->dependent_files && r->info.info8->dependent_files->string) {
1541                         info8.dependent_files   = r->info.info8->dependent_files->string;
1542                 }
1543                 if (r->info.info8->previous_names && r->info.info8->previous_names->string) {
1544                         info8.previous_names    = r->info.info8->previous_names->string;
1545                 }
1546                 info8.driver_date       = r->info.info8->driver_date;
1547                 info8.driver_version    = r->info.info8->driver_version;
1548                 info8.manufacturer_name = r->info.info8->manufacturer_name;
1549                 info8.manufacturer_url  = r->info.info8->manufacturer_url;
1550                 info8.hardware_id       = r->info.info8->hardware_id;
1551                 info8.provider          = r->info.info8->provider;
1552                 info8.print_processor   = r->info.info8->print_processor;
1553                 info8.vendor_setup      = r->info.info8->vendor_setup;
1554                 if (r->info.info8->color_profiles && r->info.info8->color_profiles->string) {
1555                         info8.color_profiles = r->info.info8->color_profiles->string;
1556                 }
1557                 info8.inf_path          = r->info.info8->inf_path;
1558                 info8.printer_driver_attributes = r->info.info8->printer_driver_attributes;
1559                 if (r->info.info8->core_driver_dependencies && r->info.info8->core_driver_dependencies->string) {
1560                         info8.core_driver_dependencies = r->info.info8->core_driver_dependencies->string;
1561                 }
1562                 info8.min_inbox_driver_ver_date = r->info.info8->min_inbox_driver_ver_date;
1563                 info8.min_inbox_driver_ver_version = r->info.info8->min_inbox_driver_ver_version;
1564                 break;
1565         default:
1566                 return false;
1567         }
1568
1569         *_info8 = info8;
1570
1571         return true;
1572 }
1573
1574
1575 /****************************************************************************
1576   Determine whether or not a particular driver is currently assigned
1577   to a printer
1578 ****************************************************************************/
1579
1580 bool printer_driver_in_use(TALLOC_CTX *mem_ctx,
1581                            const struct auth_serversupplied_info *session_info,
1582                            struct messaging_context *msg_ctx,
1583                            const struct spoolss_DriverInfo8 *r)
1584 {
1585         int snum;
1586         int n_services = lp_numservices();
1587         bool in_use = False;
1588         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
1589         WERROR result;
1590
1591         if (!r) {
1592                 return false;
1593         }
1594
1595         DEBUG(10,("printer_driver_in_use: Beginning search through ntprinters.tdb...\n"));
1596
1597         /* loop through the printers.tdb and check for the drivername */
1598
1599         for (snum=0; snum<n_services && !in_use; snum++) {
1600                 if (!lp_snum_ok(snum) || !lp_print_ok(snum)) {
1601                         continue;
1602                 }
1603
1604                 result = winreg_get_printer(mem_ctx, session_info, msg_ctx,
1605                                             lp_servicename(snum),
1606                                             &pinfo2);
1607                 if (!W_ERROR_IS_OK(result)) {
1608                         continue; /* skip */
1609                 }
1610
1611                 if (strequal(r->driver_name, pinfo2->drivername)) {
1612                         in_use = True;
1613                 }
1614
1615                 TALLOC_FREE(pinfo2);
1616         }
1617
1618         DEBUG(10,("printer_driver_in_use: Completed search through ntprinters.tdb...\n"));
1619
1620         if ( in_use ) {
1621                 struct spoolss_DriverInfo8 *driver;
1622                 WERROR werr;
1623
1624                 DEBUG(5,("printer_driver_in_use: driver \"%s\" is currently in use\n", r->driver_name));
1625
1626                 /* we can still remove the driver if there is one of
1627                    "Windows NT x86" version 2 or 3 left */
1628
1629                 if (!strequal("Windows NT x86", r->architecture)) {
1630                         werr = winreg_get_driver(mem_ctx, session_info, msg_ctx,
1631                                                  "Windows NT x86",
1632                                                  r->driver_name,
1633                                                  DRIVER_ANY_VERSION,
1634                                                  &driver);
1635                 } else if (r->version == 2) {
1636                         werr = winreg_get_driver(mem_ctx, session_info, msg_ctx,
1637                                                  "Windows NT x86",
1638                                                  r->driver_name,
1639                                                  3, &driver);
1640                 } else if (r->version == 3) {
1641                         werr = winreg_get_driver(mem_ctx, session_info, msg_ctx,
1642                                                  "Windows NT x86",
1643                                                  r->driver_name,
1644                                                  2, &driver);
1645                 } else {
1646                         DEBUG(0, ("printer_driver_in_use: ERROR!"
1647                                   " unknown driver version (%d)\n",
1648                                   r->version));
1649                         werr = WERR_UNKNOWN_PRINTER_DRIVER;
1650                 }
1651
1652                 /* now check the error code */
1653
1654                 if ( W_ERROR_IS_OK(werr) ) {
1655                         /* it's ok to remove the driver, we have other architctures left */
1656                         in_use = False;
1657                         talloc_free(driver);
1658                 }
1659         }
1660
1661         /* report that the driver is not in use by default */
1662
1663         return in_use;
1664 }
1665
1666
1667 /**********************************************************************
1668  Check to see if a ogiven file is in use by *info
1669  *********************************************************************/
1670
1671 static bool drv_file_in_use(const char *file, const struct spoolss_DriverInfo8 *info)
1672 {
1673         int i = 0;
1674
1675         if ( !info )
1676                 return False;
1677
1678         /* mz: skip files that are in the list but already deleted */
1679         if (!file || !file[0]) {
1680                 return false;
1681         }
1682
1683         if (strequal(file, info->driver_path))
1684                 return True;
1685
1686         if (strequal(file, info->data_file))
1687                 return True;
1688
1689         if (strequal(file, info->config_file))
1690                 return True;
1691
1692         if (strequal(file, info->help_file))
1693                 return True;
1694
1695         /* see of there are any dependent files to examine */
1696
1697         if (!info->dependent_files)
1698                 return False;
1699
1700         while (info->dependent_files[i] && *info->dependent_files[i]) {
1701                 if (strequal(file, info->dependent_files[i]))
1702                         return True;
1703                 i++;
1704         }
1705
1706         return False;
1707
1708 }
1709
1710 /**********************************************************************
1711  Utility function to remove the dependent file pointed to by the
1712  input parameter from the list
1713  *********************************************************************/
1714
1715 static void trim_dependent_file(TALLOC_CTX *mem_ctx, const char **files, int idx)
1716 {
1717
1718         /* bump everything down a slot */
1719
1720         while (files && files[idx+1]) {
1721                 files[idx] = talloc_strdup(mem_ctx, files[idx+1]);
1722                 idx++;
1723         }
1724
1725         files[idx] = NULL;
1726
1727         return;
1728 }
1729
1730 /**********************************************************************
1731  Check if any of the files used by src are also used by drv
1732  *********************************************************************/
1733
1734 static bool trim_overlap_drv_files(TALLOC_CTX *mem_ctx,
1735                                    struct spoolss_DriverInfo8 *src,
1736                                    const struct spoolss_DriverInfo8 *drv)
1737 {
1738         bool    in_use = False;
1739         int     i = 0;
1740
1741         if ( !src || !drv )
1742                 return False;
1743
1744         /* check each file.  Remove it from the src structure if it overlaps */
1745
1746         if (drv_file_in_use(src->driver_path, drv)) {
1747                 in_use = True;
1748                 DEBUG(10,("Removing driverfile [%s] from list\n", src->driver_path));
1749                 src->driver_path = talloc_strdup(mem_ctx, "");
1750                 if (!src->driver_path) { return false; }
1751         }
1752
1753         if (drv_file_in_use(src->data_file, drv)) {
1754                 in_use = True;
1755                 DEBUG(10,("Removing datafile [%s] from list\n", src->data_file));
1756                 src->data_file = talloc_strdup(mem_ctx, "");
1757                 if (!src->data_file) { return false; }
1758         }
1759
1760         if (drv_file_in_use(src->config_file, drv)) {
1761                 in_use = True;
1762                 DEBUG(10,("Removing configfile [%s] from list\n", src->config_file));
1763                 src->config_file = talloc_strdup(mem_ctx, "");
1764                 if (!src->config_file) { return false; }
1765         }
1766
1767         if (drv_file_in_use(src->help_file, drv)) {
1768                 in_use = True;
1769                 DEBUG(10,("Removing helpfile [%s] from list\n", src->help_file));
1770                 src->help_file = talloc_strdup(mem_ctx, "");
1771                 if (!src->help_file) { return false; }
1772         }
1773
1774         /* are there any dependentfiles to examine? */
1775
1776         if (!src->dependent_files)
1777                 return in_use;
1778
1779         while (src->dependent_files[i] && *src->dependent_files[i]) {
1780                 if (drv_file_in_use(src->dependent_files[i], drv)) {
1781                         in_use = True;
1782                         DEBUG(10,("Removing [%s] from dependent file list\n", src->dependent_files[i]));
1783                         trim_dependent_file(mem_ctx, src->dependent_files, i);
1784                 } else
1785                         i++;
1786         }
1787
1788         return in_use;
1789 }
1790
1791 /****************************************************************************
1792   Determine whether or not a particular driver files are currently being
1793   used by any other driver.
1794
1795   Return value is True if any files were in use by other drivers
1796   and False otherwise.
1797
1798   Upon return, *info has been modified to only contain the driver files
1799   which are not in use
1800
1801   Fix from mz:
1802
1803   This needs to check all drivers to ensure that all files in use
1804   have been removed from *info, not just the ones in the first
1805   match.
1806 ****************************************************************************/
1807
1808 bool printer_driver_files_in_use(TALLOC_CTX *mem_ctx,
1809                                  const struct auth_serversupplied_info *session_info,
1810                                  struct messaging_context *msg_ctx,
1811                                  struct spoolss_DriverInfo8 *info)
1812 {
1813         int                             i;
1814         uint32                          version;
1815         struct spoolss_DriverInfo8      *driver;
1816         bool in_use = false;
1817         uint32_t num_drivers;
1818         const char **drivers;
1819         WERROR result;
1820
1821         if ( !info )
1822                 return False;
1823
1824         version = info->version;
1825
1826         /* loop over all driver versions */
1827
1828         DEBUG(5,("printer_driver_files_in_use: Beginning search of drivers...\n"));
1829
1830         /* get the list of drivers */
1831
1832         result = winreg_get_driver_list(mem_ctx, session_info, msg_ctx,
1833                                         info->architecture, version,
1834                                         &num_drivers, &drivers);
1835         if (!W_ERROR_IS_OK(result)) {
1836                 return true;
1837         }
1838
1839         DEBUGADD(4, ("we have:[%d] drivers in environment [%s] and version [%d]\n",
1840                      num_drivers, info->architecture, version));
1841
1842         /* check each driver for overlap in files */
1843
1844         for (i = 0; i < num_drivers; i++) {
1845                 DEBUGADD(5,("\tdriver: [%s]\n", drivers[i]));
1846
1847                 driver = NULL;
1848
1849                 result = winreg_get_driver(mem_ctx, session_info, msg_ctx,
1850                                            info->architecture, drivers[i],
1851                                            version, &driver);
1852                 if (!W_ERROR_IS_OK(result)) {
1853                         talloc_free(drivers);
1854                         return True;
1855                 }
1856
1857                 /* check if d2 uses any files from d1 */
1858                 /* only if this is a different driver than the one being deleted */
1859
1860                 if (!strequal(info->driver_name, driver->driver_name)) {
1861                         if (trim_overlap_drv_files(mem_ctx, info, driver)) {
1862                                 /* mz: Do not instantly return -
1863                                  * we need to ensure this file isn't
1864                                  * also in use by other drivers. */
1865                                 in_use = true;
1866                         }
1867                 }
1868
1869                 talloc_free(driver);
1870         }
1871
1872         talloc_free(drivers);
1873
1874         DEBUG(5,("printer_driver_files_in_use: Completed search of drivers...\n"));
1875
1876         return in_use;
1877 }
1878
1879 static NTSTATUS driver_unlink_internals(connection_struct *conn,
1880                                         const char *name)
1881 {
1882         struct smb_filename *smb_fname = NULL;
1883         NTSTATUS status;
1884
1885         status = create_synthetic_smb_fname(talloc_tos(), name, NULL, NULL,
1886             &smb_fname);
1887         if (!NT_STATUS_IS_OK(status)) {
1888                 return status;
1889         }
1890
1891         status = unlink_internals(conn, NULL, 0, smb_fname, false);
1892
1893         TALLOC_FREE(smb_fname);
1894         return status;
1895 }
1896
1897 /****************************************************************************
1898   Actually delete the driver files.  Make sure that
1899   printer_driver_files_in_use() return False before calling
1900   this.
1901 ****************************************************************************/
1902
1903 bool delete_driver_files(const struct auth_serversupplied_info *session_info,
1904                          const struct spoolss_DriverInfo8 *r)
1905 {
1906         int i = 0;
1907         char *s;
1908         const char *file;
1909         connection_struct *conn;
1910         NTSTATUS nt_status;
1911         char *oldcwd;
1912         char *printdollar = NULL;
1913         int printdollar_snum;
1914         bool ret = false;
1915
1916         if (!r) {
1917                 return false;
1918         }
1919
1920         DEBUG(6,("delete_driver_files: deleting driver [%s] - version [%d]\n",
1921                 r->driver_name, r->version));
1922
1923         printdollar_snum = find_service(talloc_tos(), "print$", &printdollar);
1924         if (!printdollar) {
1925                 return false;
1926         }
1927         if (printdollar_snum == -1) {
1928                 return false;
1929         }
1930
1931         nt_status = create_conn_struct(talloc_tos(), &conn, printdollar_snum,
1932                                        lp_pathname(printdollar_snum),
1933                                        session_info, &oldcwd);
1934         if (!NT_STATUS_IS_OK(nt_status)) {
1935                 DEBUG(0,("delete_driver_files: create_conn_struct "
1936                          "returned %s\n", nt_errstr(nt_status)));
1937                 return false;
1938         }
1939
1940         nt_status = set_conn_force_user_group(conn, printdollar_snum);
1941         if (!NT_STATUS_IS_OK(nt_status)) {
1942                 DEBUG(0, ("failed set force user / group\n"));
1943                 ret = false;
1944                 goto err_free_conn;
1945         }
1946
1947         if (!become_user(conn, get_current_vuid(conn))) {
1948                 DEBUG(0, ("failed to become user\n"));
1949                 ret = false;
1950                 goto err_free_conn;
1951         }
1952
1953         if ( !CAN_WRITE(conn) ) {
1954                 DEBUG(3,("delete_driver_files: Cannot delete print driver when [print$] is read-only\n"));
1955                 ret = false;
1956                 goto err_out;
1957         }
1958
1959         /* now delete the files; must strip the '\print$' string from
1960            fron of path                                                */
1961
1962         if (r->driver_path && r->driver_path[0]) {
1963                 if ((s = strchr(&r->driver_path[1], '\\')) != NULL) {
1964                         file = s;
1965                         DEBUG(10,("deleting driverfile [%s]\n", s));
1966                         driver_unlink_internals(conn, file);
1967                 }
1968         }
1969
1970         if (r->config_file && r->config_file[0]) {
1971                 if ((s = strchr(&r->config_file[1], '\\')) != NULL) {
1972                         file = s;
1973                         DEBUG(10,("deleting configfile [%s]\n", s));
1974                         driver_unlink_internals(conn, file);
1975                 }
1976         }
1977
1978         if (r->data_file && r->data_file[0]) {
1979                 if ((s = strchr(&r->data_file[1], '\\')) != NULL) {
1980                         file = s;
1981                         DEBUG(10,("deleting datafile [%s]\n", s));
1982                         driver_unlink_internals(conn, file);
1983                 }
1984         }
1985
1986         if (r->help_file && r->help_file[0]) {
1987                 if ((s = strchr(&r->help_file[1], '\\')) != NULL) {
1988                         file = s;
1989                         DEBUG(10,("deleting helpfile [%s]\n", s));
1990                         driver_unlink_internals(conn, file);
1991                 }
1992         }
1993
1994         /* check if we are done removing files */
1995
1996         if (r->dependent_files) {
1997                 while (r->dependent_files[i] && r->dependent_files[i][0]) {
1998                         char *p;
1999
2000                         /* bypass the "\print$" portion of the path */
2001
2002                         if ((p = strchr(r->dependent_files[i]+1, '\\')) != NULL) {
2003                                 file = p;
2004                                 DEBUG(10,("deleting dependent file [%s]\n", file));
2005                                 driver_unlink_internals(conn, file);
2006                         }
2007
2008                         i++;
2009                 }
2010         }
2011
2012         ret = true;
2013  err_out:
2014         unbecome_user();
2015  err_free_conn:
2016         if (conn != NULL) {
2017                 vfs_ChDir(conn, oldcwd);
2018                 SMB_VFS_DISCONNECT(conn);
2019                 conn_free(conn);
2020         }
2021         return ret;
2022 }
2023
2024 /* error code:
2025         0: everything OK
2026         1: level not implemented
2027         2: file doesn't exist
2028         3: can't allocate memory
2029         4: can't free memory
2030         5: non existant struct
2031 */
2032
2033 /*
2034         A printer and a printer driver are 2 different things.
2035         NT manages them separatelly, Samba does the same.
2036         Why ? Simply because it's easier and it makes sense !
2037
2038         Now explanation: You have 3 printers behind your samba server,
2039         2 of them are the same make and model (laser A and B). But laser B
2040         has an 3000 sheet feeder and laser A doesn't such an option.
2041         Your third printer is an old dot-matrix model for the accounting :-).
2042
2043         If the /usr/local/samba/lib directory (default dir), you will have
2044         5 files to describe all of this.
2045
2046         3 files for the printers (1 by printer):
2047                 NTprinter_laser A
2048                 NTprinter_laser B
2049                 NTprinter_accounting
2050         2 files for the drivers (1 for the laser and 1 for the dot matrix)
2051                 NTdriver_printer model X
2052                 NTdriver_printer model Y
2053
2054 jfm: I should use this comment for the text file to explain
2055         same thing for the forms BTW.
2056         Je devrais mettre mes commentaires en francais, ca serait mieux :-)
2057
2058 */
2059
2060 /* Convert generic access rights to printer object specific access rights.
2061    It turns out that NT4 security descriptors use generic access rights and
2062    NT5 the object specific ones. */
2063
2064 void map_printer_permissions(struct security_descriptor *sd)
2065 {
2066         int i;
2067
2068         for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
2069                 se_map_generic(&sd->dacl->aces[i].access_mask,
2070                                &printer_generic_mapping);
2071         }
2072 }
2073
2074 void map_job_permissions(struct security_descriptor *sd)
2075 {
2076         int i;
2077
2078         for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
2079                 se_map_generic(&sd->dacl->aces[i].access_mask,
2080                                &job_generic_mapping);
2081         }
2082 }
2083
2084
2085 /****************************************************************************
2086  Check a user has permissions to perform the given operation.  We use the
2087  permission constants defined in include/rpc_spoolss.h to check the various
2088  actions we perform when checking printer access.
2089
2090    PRINTER_ACCESS_ADMINISTER:
2091        print_queue_pause, print_queue_resume, update_printer_sec,
2092        update_printer, spoolss_addprinterex_level_2,
2093        _spoolss_setprinterdata
2094
2095    PRINTER_ACCESS_USE:
2096        print_job_start
2097
2098    JOB_ACCESS_ADMINISTER:
2099        print_job_delete, print_job_pause, print_job_resume,
2100        print_queue_purge
2101
2102   Try access control in the following order (for performance reasons):
2103     1)  root and SE_PRINT_OPERATOR can do anything (easy check)
2104     2)  check security descriptor (bit comparisons in memory)
2105     3)  "printer admins" (may result in numerous calls to winbind)
2106
2107  ****************************************************************************/
2108 bool print_access_check(const struct auth_serversupplied_info *session_info,
2109                         struct messaging_context *msg_ctx, int snum,
2110                         int access_type)
2111 {
2112         struct spoolss_security_descriptor *secdesc = NULL;
2113         uint32 access_granted;
2114         size_t sd_size;
2115         NTSTATUS status;
2116         WERROR result;
2117         const char *pname;
2118         TALLOC_CTX *mem_ctx = NULL;
2119
2120         /* If user is NULL then use the current_user structure */
2121
2122         /* Always allow root or SE_PRINT_OPERATROR to do anything */
2123
2124         if (session_info->utok.uid == sec_initial_uid()
2125             || security_token_has_privilege(session_info->security_token, SEC_PRIV_PRINT_OPERATOR)) {
2126                 return True;
2127         }
2128
2129         /* Get printer name */
2130
2131         pname = lp_printername(snum);
2132
2133         if (!pname || !*pname) {
2134                 errno = EACCES;
2135                 return False;
2136         }
2137
2138         /* Get printer security descriptor */
2139
2140         if(!(mem_ctx = talloc_init("print_access_check"))) {
2141                 errno = ENOMEM;
2142                 return False;
2143         }
2144
2145         result = winreg_get_printer_secdesc(mem_ctx,
2146                                             get_session_info_system(),
2147                                             msg_ctx,
2148                                             pname,
2149                                             &secdesc);
2150         if (!W_ERROR_IS_OK(result)) {
2151                 talloc_destroy(mem_ctx);
2152                 errno = ENOMEM;
2153                 return False;
2154         }
2155
2156         if (access_type == JOB_ACCESS_ADMINISTER) {
2157                 struct spoolss_security_descriptor *parent_secdesc = secdesc;
2158
2159                 /* Create a child security descriptor to check permissions
2160                    against.  This is because print jobs are child objects
2161                    objects of a printer. */
2162                 status = se_create_child_secdesc(mem_ctx,
2163                                                  &secdesc,
2164                                                  &sd_size,
2165                                                  parent_secdesc,
2166                                                  parent_secdesc->owner_sid,
2167                                                  parent_secdesc->group_sid,
2168                                                  false);
2169                 if (!NT_STATUS_IS_OK(status)) {
2170                         talloc_destroy(mem_ctx);
2171                         errno = map_errno_from_nt_status(status);
2172                         return False;
2173                 }
2174
2175                 map_job_permissions(secdesc);
2176         } else {
2177                 map_printer_permissions(secdesc);
2178         }
2179
2180         /* Check access */
2181         status = se_access_check(secdesc, session_info->security_token, access_type,
2182                                  &access_granted);
2183
2184         DEBUG(4, ("access check was %s\n", NT_STATUS_IS_OK(status) ? "SUCCESS" : "FAILURE"));
2185
2186         /* see if we need to try the printer admin list */
2187
2188         if (!NT_STATUS_IS_OK(status) &&
2189             (token_contains_name_in_list(uidtoname(session_info->utok.uid),
2190                                          session_info->info3->base.domain.string,
2191                                          NULL, session_info->security_token,
2192                                          lp_printer_admin(snum)))) {
2193                 talloc_destroy(mem_ctx);
2194                 return True;
2195         }
2196
2197         talloc_destroy(mem_ctx);
2198
2199         if (!NT_STATUS_IS_OK(status)) {
2200                 errno = EACCES;
2201         }
2202
2203         return NT_STATUS_IS_OK(status);
2204 }
2205
2206 /****************************************************************************
2207  Check the time parameters allow a print operation.
2208 *****************************************************************************/
2209
2210 bool print_time_access_check(const struct auth_serversupplied_info *session_info,
2211                              struct messaging_context *msg_ctx,
2212                              const char *servicename)
2213 {
2214         struct spoolss_PrinterInfo2 *pinfo2 = NULL;
2215         WERROR result;
2216         bool ok = False;
2217         time_t now = time(NULL);
2218         struct tm *t;
2219         uint32 mins;
2220
2221         result = winreg_get_printer(NULL, session_info, msg_ctx,
2222                                     servicename, &pinfo2);
2223         if (!W_ERROR_IS_OK(result)) {
2224                 return False;
2225         }
2226
2227         if (pinfo2->starttime == 0 && pinfo2->untiltime == 0) {
2228                 ok = True;
2229         }
2230
2231         t = gmtime(&now);
2232         mins = (uint32)t->tm_hour*60 + (uint32)t->tm_min;
2233
2234         if (mins >= pinfo2->starttime && mins <= pinfo2->untiltime) {
2235                 ok = True;
2236         }
2237
2238         TALLOC_FREE(pinfo2);
2239
2240         if (!ok) {
2241                 errno = EACCES;
2242         }
2243
2244         return ok;
2245 }
2246
2247 void nt_printer_remove(TALLOC_CTX *mem_ctx,
2248                         const struct auth_serversupplied_info *session_info,
2249                         struct messaging_context *msg_ctx,
2250                         const char *printer)
2251 {
2252         WERROR result;
2253
2254         result = winreg_delete_printer_key(mem_ctx, session_info, msg_ctx,
2255                                            printer, "");
2256         if (!W_ERROR_IS_OK(result)) {
2257                 DEBUG(0, ("nt_printer_remove: failed to remove rpinter %s",
2258                           printer));
2259         }
2260 }