528
517
#define RAP_QUEUE_STATUS_PAUSED 1
529
518
#define RAP_QUEUE_STATUS_ERROR 2
531
/* turn a print job status into a on the wire status
520
/* turn a print job status into a on the wire status
533
static int printj_status(int v)
522
static int printj_spoolss_status(int v)
524
if (v == JOB_STATUS_QUEUED)
537
525
return RAP_JOB_STATUS_QUEUED;
526
if (v & JOB_STATUS_PAUSED)
539
527
return RAP_JOB_STATUS_PAUSED;
528
if (v & JOB_STATUS_SPOOLING)
541
529
return RAP_JOB_STATUS_SPOOLING;
530
if (v & JOB_STATUS_PRINTING)
543
531
return RAP_JOB_STATUS_PRINTING;
548
/* turn a print queue status into a on the wire status
535
/* turn a print queue status into a on the wire status
550
static int printq_status(int v)
537
static int printq_spoolss_status(int v)
539
if (v == PRINTER_STATUS_OK)
541
if (v & PRINTER_STATUS_PAUSED)
556
542
return RAP_QUEUE_STATUS_PAUSED;
558
543
return RAP_QUEUE_STATUS_ERROR;
561
static void fill_printjob_info(connection_struct *conn, int snum, int uLevel,
562
struct pack_desc *desc,
563
print_queue_struct *queue, int n)
546
static void fill_spoolss_printjob_info(int uLevel,
547
struct pack_desc *desc,
548
struct spoolss_JobInfo2 *info2,
565
time_t t = queue->time;
551
time_t t = spoolss_Time_to_time_t(&info2->submitted);
567
553
/* the client expects localtime */
568
554
t -= get_time_zone(t);
570
PACKI(desc,"W",pjobid_to_rap(lp_const_servicename(snum),queue->job)); /* uJobId */
556
PACKI(desc,"W",pjobid_to_rap(info2->printer_name, info2->job_id)); /* uJobId */
571
557
if (uLevel == 1) {
572
PACKS(desc,"B21",queue->fs_user); /* szUserName */
558
PACKS(desc,"B21", info2->user_name); /* szUserName */
573
559
PACKS(desc,"B",""); /* pad */
574
560
PACKS(desc,"B16",""); /* szNotifyName */
575
561
PACKS(desc,"B10","PM_Q_RAW"); /* szDataType */
576
562
PACKS(desc,"z",""); /* pszParms */
577
563
PACKI(desc,"W",n+1); /* uPosition */
578
PACKI(desc,"W",printj_status(queue->status)); /* fsStatus */
564
PACKI(desc,"W", printj_spoolss_status(info2->status)); /* fsStatus */
579
565
PACKS(desc,"z",""); /* pszStatus */
580
PACKI(desc,"D",t); /* ulSubmitted */
581
PACKI(desc,"D",queue->size); /* ulSize */
582
PACKS(desc,"z",queue->fs_file); /* pszComment */
566
PACKI(desc,"D", t); /* ulSubmitted */
567
PACKI(desc,"D", info2->size); /* ulSize */
568
PACKS(desc,"z", info2->document_name); /* pszComment */
584
570
if (uLevel == 2 || uLevel == 3 || uLevel == 4) {
585
PACKI(desc,"W",queue->priority); /* uPriority */
586
PACKS(desc,"z",queue->fs_user); /* pszUserName */
571
PACKI(desc,"W", info2->priority); /* uPriority */
572
PACKS(desc,"z", info2->user_name); /* pszUserName */
587
573
PACKI(desc,"W",n+1); /* uPosition */
588
PACKI(desc,"W",printj_status(queue->status)); /* fsStatus */
574
PACKI(desc,"W", printj_spoolss_status(info2->status)); /* fsStatus */
589
575
PACKI(desc,"D",t); /* ulSubmitted */
590
PACKI(desc,"D",queue->size); /* ulSize */
576
PACKI(desc,"D", info2->size); /* ulSize */
591
577
PACKS(desc,"z","Samba"); /* pszComment */
592
PACKS(desc,"z",queue->fs_file); /* pszDocument */
578
PACKS(desc,"z", info2->document_name); /* pszDocument */
593
579
if (uLevel == 3) {
594
580
PACKS(desc,"z",""); /* pszNotifyName */
595
581
PACKS(desc,"z","PM_Q_RAW"); /* pszDataType */
596
582
PACKS(desc,"z",""); /* pszParms */
597
583
PACKS(desc,"z",""); /* pszStatus */
598
PACKS(desc,"z",SERVICE(snum)); /* pszQueue */
584
PACKS(desc,"z", info2->printer_name); /* pszQueue */
599
585
PACKS(desc,"z","lpd"); /* pszQProcName */
600
586
PACKS(desc,"z",""); /* pszQProcParms */
601
587
PACKS(desc,"z","NULL"); /* pszDriverName */
619
605
/********************************************************************
620
Return a driver name given an snum.
621
Returns True if from tdb, False otherwise.
622
********************************************************************/
624
static bool get_driver_name(int snum, char **pp_drivername)
626
NT_PRINTER_INFO_LEVEL *info = NULL;
629
get_a_printer (NULL, &info, 2, lp_servicename(snum));
631
*pp_drivername = talloc_strdup(talloc_tos(),
632
info->info_2->drivername);
634
free_a_printer(&info, 2);
635
if (!*pp_drivername) {
643
/********************************************************************
644
606
Respond to the DosPrintQInfo command with a level of 52
645
607
This is used to get printer driver information for Win9x clients
646
608
********************************************************************/
647
static void fill_printq_info_52(connection_struct *conn, int snum,
648
struct pack_desc* desc, int count )
609
static void fill_printq_info_52(struct spoolss_DriverInfo3 *driver,
610
struct pack_desc* desc, int count,
611
const char *printer_name)
651
614
fstring location;
652
struct spoolss_DriverInfo8 *driver = NULL;
653
NT_PRINTER_INFO_LEVEL *printer = NULL;
655
if ( !W_ERROR_IS_OK(get_a_printer( NULL, &printer, 2, lp_servicename(snum))) ) {
656
DEBUG(3,("fill_printq_info_52: Failed to lookup printer [%s]\n",
657
lp_servicename(snum)));
661
if (!W_ERROR_IS_OK(get_a_printer_driver(talloc_tos(), &driver, printer->info_2->drivername,
664
DEBUG(3,("fill_printq_info_52: Failed to lookup driver [%s]\n",
665
printer->info_2->drivername));
669
615
trim_string((char *)driver->driver_path, "\\print$\\WIN40\\0\\", 0);
670
616
trim_string((char *)driver->data_file, "\\print$\\WIN40\\0\\", 0);
671
617
trim_string((char *)driver->help_file, "\\print$\\WIN40\\0\\", 0);
705
651
DEBUG(3,("fill_printq_info_52: file count specified by client [%d] != number of dependent files [%i]\n",
708
DEBUG(3,("fill_printq_info on <%s> gave %d entries\n", SERVICE(snum),i));
654
DEBUG(3,("fill_printq_info on <%s> gave %d entries\n", printer_name, i));
710
656
desc->errcode=NERR_Success;
714
DEBUG(3,("fill_printq_info: Can't supply driver files\n"));
715
desc->errcode=NERR_notsupported;
719
free_a_printer( &printer, 2 );
721
free_a_printer_driver(driver);
725
static void fill_printq_info(connection_struct *conn, int snum, int uLevel,
660
static const char *strip_unc(const char *unc)
668
if ((p = strrchr(unc, '\\')) != NULL) {
675
static void fill_printq_info(int uLevel,
726
676
struct pack_desc* desc,
727
int count, print_queue_struct* queue,
728
print_status_struct* status)
678
union spoolss_JobInfo *job_info,
679
struct spoolss_DriverInfo3 *driver_info,
680
struct spoolss_PrinterInfo2 *printer_info)
730
682
switch (uLevel) {
733
PACKS(desc,"B13",SERVICE(snum));
686
PACKS(desc,"B13", strip_unc(printer_info->printername));
738
PACKS(desc,"z",Expand(conn,snum,SERVICE(snum)));
691
PACKS(desc,"z", strip_unc(printer_info->printername));
741
PACKI(desc,"K",printq_status(status->status));
694
PACKI(desc,"K", printq_spoolss_status(printer_info->status));
749
702
PACKI(desc,"W",0); /* until time */
750
703
PACKS(desc,"z",""); /* pSepFile */
751
704
PACKS(desc,"z","lpd"); /* pPrProc */
752
PACKS(desc,"z",SERVICE(snum)); /* pDestinations */
705
PACKS(desc,"z", strip_unc(printer_info->printername)); /* pDestinations */
753
706
PACKS(desc,"z",""); /* pParms */
707
if (printer_info->printername == NULL) {
755
708
PACKS(desc,"z","UNKNOWN PRINTER");
756
709
PACKI(desc,"W",LPSTAT_ERROR);
758
else if (!status || !status->message[0]) {
759
PACKS(desc,"z",Expand(conn,snum,lp_comment(snum)));
760
PACKI(desc,"W",LPSTAT_OK); /* status */
762
PACKS(desc,"z",status->message);
763
PACKI(desc,"W",printq_status(status->status)); /* status */
711
PACKS(desc,"z", printer_info->comment);
712
PACKI(desc,"W", printq_spoolss_status(printer_info->status)); /* status */
765
714
PACKI(desc,(uLevel == 1 ? "W" : "N"),count);
768
717
if (uLevel == 3 || uLevel == 4) {
769
char *drivername = NULL;
771
718
PACKI(desc,"W",5); /* uPriority */
772
719
PACKI(desc,"W",0); /* uStarttime */
773
720
PACKI(desc,"W",0); /* uUntiltime */
778
725
PACKS(desc,"z",NULL); /* pszComment - don't ask.... JRA */
779
726
/* "don't ask" that it's done this way to fix corrupted
780
727
Win9X/ME printer comments. */
782
PACKI(desc,"W",LPSTAT_OK); /* fsStatus */
784
PACKI(desc,"W",printq_status(status->status)); /* fsStatus */
728
PACKI(desc,"W", printq_spoolss_status(printer_info->status)); /* fsStatus */
786
729
PACKI(desc,(uLevel == 3 ? "W" : "N"),count); /* cJobs */
787
PACKS(desc,"z",SERVICE(snum)); /* pszPrinters */
788
get_driver_name(snum,&drivername);
792
PACKS(desc,"z",drivername); /* pszDriverName */
730
PACKS(desc,"z", strip_unc(printer_info->printername)); /* pszPrinters */
731
PACKS(desc,"z", printer_info->drivername); /* pszDriverName */
793
732
PackDriverData(desc); /* pDriverData */
796
735
if (uLevel == 2 || uLevel == 4) {
798
for (i=0;i<count;i++)
799
fill_printjob_info(conn,snum,uLevel == 2 ? 1 : 2,desc,&queue[i],i);
737
for (i = 0; i < count; i++) {
738
fill_spoolss_printjob_info(uLevel == 2 ? 1 : 2, desc, &job_info[i].info2, i);
803
fill_printq_info_52( conn, snum, desc, count );
743
fill_printq_info_52(driver_info, desc, count, printer_info->printername);
806
746
/* This function returns the number of files for a given driver */
807
static int get_printerdrivernumber(int snum)
747
static int get_printerdrivernumber(const struct spoolss_DriverInfo3 *driver)
810
struct spoolss_DriverInfo8 *driver;
811
NT_PRINTER_INFO_LEVEL *printer = NULL;
815
if ( !W_ERROR_IS_OK(get_a_printer( NULL, &printer, 2, lp_servicename(snum))) ) {
816
DEBUG(3,("get_printerdrivernumber: Failed to lookup printer [%s]\n",
817
lp_servicename(snum)));
821
if (!W_ERROR_IS_OK(get_a_printer_driver(talloc_tos(), &driver, printer->info_2->drivername,
824
DEBUG(3,("get_printerdrivernumber: Failed to lookup driver [%s]\n",
825
printer->info_2->drivername));
829
751
/* count the number of files */
830
752
while (driver->dependent_files && *driver->dependent_files[result])
834
free_a_printer( &printer, 2 );
836
free_a_printer_driver(driver);
841
static bool api_DosPrintQGetInfo(connection_struct *conn, uint16 vuid,
758
static bool api_DosPrintQGetInfo(struct smbd_server_connection *sconn,
759
connection_struct *conn, uint16 vuid,
842
760
char *param, int tpscnt,
843
761
char *data, int tdscnt,
844
762
int mdrcnt,int mprcnt,
902
snum = find_service(QueueName);
903
if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
829
if (QueueName == NULL || (strlen(QueueName) < 1)) {
830
desc.errcode = W_ERROR_V(WERR_INVALID_PARAM);
834
status = rpc_pipe_open_interface(conn,
835
&ndr_table_spoolss.syntax_id,
837
&conn->sconn->client_id,
838
conn->sconn->msg_ctx,
840
if (!NT_STATUS_IS_OK(status)) {
841
DEBUG(0,("api_DosPrintQGetInfo: could not connect to spoolss: %s\n",
843
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
846
b = cli->binding_handle;
848
ZERO_STRUCT(devmode_ctr);
850
status = dcerpc_spoolss_OpenPrinter(b, mem_ctx,
857
if (!NT_STATUS_IS_OK(status)) {
858
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
861
if (!W_ERROR_IS_OK(werr)) {
862
desc.errcode = W_ERROR_V(werr);
866
werr = rpccli_spoolss_getprinter(cli, mem_ctx,
871
if (!W_ERROR_IS_OK(werr)) {
872
desc.errcode = W_ERROR_V(werr);
906
876
if (uLevel==52) {
907
count = get_printerdrivernumber(snum);
877
uint32_t server_major_version;
878
uint32_t server_minor_version;
880
werr = rpccli_spoolss_getprinterdriver2(cli, mem_ctx,
888
&server_major_version,
889
&server_minor_version);
890
if (!W_ERROR_IS_OK(werr)) {
891
desc.errcode = W_ERROR_V(werr);
895
count = get_printerdrivernumber(&driver_info.info3);
908
896
DEBUG(3,("api_DosPrintQGetInfo: Driver files count: %d\n",count));
910
count = print_queue_status(snum, &queue,&status);
899
werr = rpccli_spoolss_enumjobs(cli, mem_ctx,
907
if (!W_ERROR_IS_OK(werr)) {
908
desc.errcode = W_ERROR_V(werr);
913
915
if (mdrcnt > 0) {
914
916
*rdata = smb_realloc_limit(*rdata,mdrcnt);
919
920
desc.base = *rdata;
1018
for (i = 0; i < services; i++) {
1019
if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
1024
if((queue = SMB_MALLOC_ARRAY(print_queue_struct*, queuecnt)) == NULL) {
1025
DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
1028
memset(queue,0,queuecnt*sizeof(print_queue_struct*));
1029
if((status = SMB_MALLOC_ARRAY(print_status_struct,queuecnt)) == NULL) {
1030
DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
1033
memset(status,0,queuecnt*sizeof(print_status_struct));
1031
status = rpc_pipe_open_interface(conn,
1032
&ndr_table_spoolss.syntax_id,
1034
&conn->sconn->client_id,
1035
conn->sconn->msg_ctx,
1037
if (!NT_STATUS_IS_OK(status)) {
1038
DEBUG(0,("api_DosPrintQEnum: could not connect to spoolss: %s\n",
1039
nt_errstr(status)));
1040
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
1043
b = cli->binding_handle;
1045
werr = rpccli_spoolss_enumprinters(cli, mem_ctx,
1047
cli->srv_name_slash,
1052
if (!W_ERROR_IS_OK(werr)) {
1053
desc.errcode = W_ERROR_V(werr);
1057
queuecnt = num_printers;
1059
job_info = talloc_array(mem_ctx, union spoolss_JobInfo *, num_printers);
1060
if (job_info == NULL) {
1064
driver_info = talloc_array(mem_ctx, union spoolss_DriverInfo, num_printers);
1065
if (driver_info == NULL) {
1034
1069
if((subcntarr = SMB_MALLOC_ARRAY(int,queuecnt)) == NULL) {
1035
1070
DEBUG(0,("api_DosPrintQEnum: malloc fail !\n"));
1075
*rdata = smb_realloc_limit(*rdata,mdrcnt);
1081
desc.buflen = mdrcnt;
1041
for (i = 0; i < services; i++) {
1042
if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
1043
subcntarr[n] = print_queue_status(i, &queue[n],&status[n]);
1044
subcnt += subcntarr[n];
1050
*rdata = smb_realloc_limit(*rdata,mdrcnt);
1084
for (i = 0; i < num_printers; i++) {
1087
struct policy_handle handle;
1088
const char *printername;
1090
printername = talloc_strdup(mem_ctx, printer_info[i].info2.printername);
1091
if (printername == NULL) {
1095
ZERO_STRUCT(handle);
1096
ZERO_STRUCT(devmode_ctr);
1098
status = dcerpc_spoolss_OpenPrinter(b, mem_ctx,
1105
if (!NT_STATUS_IS_OK(status)) {
1106
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
1109
if (!W_ERROR_IS_OK(werr)) {
1110
desc.errcode = W_ERROR_V(werr);
1114
werr = rpccli_spoolss_enumjobs(cli, mem_ctx,
1122
if (!W_ERROR_IS_OK(werr)) {
1123
desc.errcode = W_ERROR_V(werr);
1128
uint32_t server_major_version;
1129
uint32_t server_minor_version;
1131
werr = rpccli_spoolss_getprinterdriver2(cli, mem_ctx,
1139
&server_major_version,
1140
&server_minor_version);
1141
if (!W_ERROR_IS_OK(werr)) {
1142
desc.errcode = W_ERROR_V(werr);
1147
subcntarr[i] = num_jobs;
1148
subcnt += subcntarr[i];
1150
dcerpc_spoolss_ClosePrinter(b, mem_ctx, &handle, &werr);
1056
desc.buflen = mdrcnt;
1058
1153
if (init_package(&desc,queuecnt,subcnt)) {
1061
for (i = 0; i < services; i++) {
1062
if (lp_snum_ok(i) && lp_print_ok(i) && lp_browseable(i)) {
1063
fill_printq_info(conn,i,uLevel,&desc,subcntarr[n],queue[n],&status[n]);
1065
if (desc.errcode == NERR_Success) {
1154
for (i = 0; i < num_printers; i++) {
1155
fill_printq_info(uLevel,&desc,subcntarr[i], job_info[i], &driver_info[i].info3, &printer_info[i].info2);
1156
if (desc.errcode == NERR_Success) {
1072
1162
SAFE_FREE(subcntarr);
1074
1164
*rdata_len = desc.usedlen;
1075
1165
*rparam_len = 8;
1076
1166
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2179
string_replace(sharename, '"', ' ');
2180
string_replace(pathname, '"', ' ');
2181
string_replace(comment, '"', ' ');
2183
cmdname = lp_add_share_cmd();
2185
if (!cmdname || *cmdname == '\0') {
2189
if (asprintf(&command, "%s \"%s\" \"%s\" \"%s\" \"%s\"",
2190
lp_add_share_cmd(), get_dyn_CONFIGFILE(), sharename,
2191
pathname, comment) == -1) {
2195
DEBUG(10,("api_RNetShareAdd: Running [%s]\n", command ));
2197
if ((res = smbrun(command, NULL)) != 0) {
2198
DEBUG(1,("api_RNetShareAdd: Running [%s] returned (%d)\n",
2205
message_send_all(smbd_messaging_context(),
2206
MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
2257
status = rpc_pipe_open_interface(mem_ctx, &ndr_table_srvsvc.syntax_id,
2259
&conn->sconn->client_id,
2260
conn->sconn->msg_ctx,
2262
if (!NT_STATUS_IS_OK(status)) {
2263
DEBUG(0,("api_RNetShareAdd: could not connect to srvsvc: %s\n",
2264
nt_errstr(status)));
2265
res = W_ERROR_V(ntstatus_to_werror(status));
2269
b = cli->binding_handle;
2271
info2.name = sharename;
2272
info2.type = STYPE_DISKTREE;
2273
info2.comment = comment;
2274
info2.permissions = 0;
2275
info2.max_users = 0;
2276
info2.current_users = 0;
2277
info2.path = pathname;
2278
info2.password = NULL;
2280
info.info2 = &info2;
2282
status = dcerpc_srvsvc_NetShareAdd(b, mem_ctx,
2283
cli->srv_name_slash,
2288
if (!NT_STATUS_IS_OK(status)) {
2289
res = W_ERROR_V(ntstatus_to_werror(status));
2292
if (!W_ERROR_IS_OK(werr)) {
2293
res = W_ERROR_V(werr);
2209
2297
*rparam_len = 6;
2278
status = rpc_pipe_open_internal(
2279
talloc_tos(), &ndr_table_samr.syntax_id, rpc_samr_dispatch,
2280
conn->server_info, &samr_pipe);
2368
status = rpc_pipe_open_interface(
2369
talloc_tos(), &ndr_table_samr.syntax_id,
2370
conn->session_info, &conn->sconn->client_id,
2371
conn->sconn->msg_ctx, &samr_pipe);
2281
2372
if (!NT_STATUS_IS_OK(status)) {
2282
2373
DEBUG(0, ("api_RNetUserEnum: Could not connect to samr: %s\n",
2283
2374
nt_errstr(status)));
2287
status = rpccli_samr_Connect2(samr_pipe, talloc_tos(), global_myname(),
2288
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle);
2378
b = samr_pipe->binding_handle;
2380
status = dcerpc_samr_Connect2(b, talloc_tos(), global_myname(),
2381
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle,
2289
2383
if (!NT_STATUS_IS_OK(status)) {
2290
2384
DEBUG(0, ("api_RNetUserEnum: samr_Connect2 failed: %s\n",
2291
2385
nt_errstr(status)));
2388
if (!NT_STATUS_IS_OK(result)) {
2389
DEBUG(0, ("api_RNetUserEnum: samr_Connect2 failed: %s\n",
2390
nt_errstr(result)));
2295
status = rpccli_samr_OpenDomain(samr_pipe, talloc_tos(), &samr_handle,
2394
status = dcerpc_samr_OpenDomain(b, talloc_tos(), &samr_handle,
2296
2395
SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS,
2297
get_global_sam_sid(), &domain_handle);
2396
get_global_sam_sid(), &domain_handle,
2298
2398
if (!NT_STATUS_IS_OK(status)) {
2299
2399
DEBUG(0, ("api_RNetUserEnum: samr_OpenDomain failed: %s\n",
2300
2400
nt_errstr(status)));
2301
rpccli_samr_Close(samr_pipe, talloc_tos(), &samr_handle);
2401
dcerpc_samr_Close(b, talloc_tos(), &samr_handle, &result);
2404
if (!NT_STATUS_IS_OK(result)) {
2405
DEBUG(0, ("api_RNetUserEnum: samr_OpenDomain failed: %s\n",
2406
nt_errstr(result)));
2407
dcerpc_samr_Close(b, talloc_tos(), &samr_handle, &result);
2457
2572
endp = *rdata + *rdata_len;
2459
status = rpc_pipe_open_internal(
2460
talloc_tos(), &ndr_table_samr.syntax_id, rpc_samr_dispatch,
2461
conn->server_info, &samr_pipe);
2574
status = rpc_pipe_open_interface(
2575
talloc_tos(), &ndr_table_samr.syntax_id,
2576
conn->session_info, &conn->sconn->client_id,
2577
conn->sconn->msg_ctx, &samr_pipe);
2462
2578
if (!NT_STATUS_IS_OK(status)) {
2463
2579
DEBUG(0, ("api_RNetUserEnum: Could not connect to samr: %s\n",
2464
2580
nt_errstr(status)));
2468
status = rpccli_samr_Connect2(samr_pipe, talloc_tos(), global_myname(),
2469
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle);
2584
b = samr_pipe->binding_handle;
2586
status = dcerpc_samr_Connect2(b, talloc_tos(), global_myname(),
2587
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle,
2470
2589
if (!NT_STATUS_IS_OK(status)) {
2471
2590
DEBUG(0, ("api_RNetUserEnum: samr_Connect2 failed: %s\n",
2472
2591
nt_errstr(status)));
2594
if (!NT_STATUS_IS_OK(result)) {
2595
DEBUG(0, ("api_RNetUserEnum: samr_Connect2 failed: %s\n",
2596
nt_errstr(result)));
2476
status = rpccli_samr_OpenDomain(samr_pipe, talloc_tos(), &samr_handle,
2600
status = dcerpc_samr_OpenDomain(b, talloc_tos(), &samr_handle,
2477
2601
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
2478
get_global_sam_sid(), &domain_handle);
2602
get_global_sam_sid(), &domain_handle,
2479
2604
if (!NT_STATUS_IS_OK(status)) {
2480
2605
DEBUG(0, ("api_RNetUserEnum: samr_OpenDomain failed: %s\n",
2481
2606
nt_errstr(status)));
2482
2607
goto close_sam;
2609
if (!NT_STATUS_IS_OK(result)) {
2610
DEBUG(0, ("api_RNetUserEnum: samr_OpenDomain failed: %s\n",
2611
nt_errstr(result)));
2485
2615
name.string = UserName;
2487
status = rpccli_samr_LookupNames(samr_pipe, talloc_tos(),
2617
status = dcerpc_samr_LookupNames(b, talloc_tos(),
2488
2618
&domain_handle, 1, &name,
2490
2621
if (!NT_STATUS_IS_OK(status)) {
2491
2622
DEBUG(0, ("api_RNetUserEnum: samr_LookupNames failed: %s\n",
2492
2623
nt_errstr(status)));
2493
2624
goto close_domain;
2626
if (!NT_STATUS_IS_OK(result)) {
2627
DEBUG(0, ("api_RNetUserEnum: samr_LookupNames failed: %s\n",
2628
nt_errstr(result)));
2496
2632
if (type.ids[0] != SID_NAME_USER) {
2497
2633
DEBUG(10, ("%s is a %s, not a user\n", UserName,
2499
2635
goto close_domain;
2502
status = rpccli_samr_OpenUser(samr_pipe, talloc_tos(),
2638
status = dcerpc_samr_OpenUser(b, talloc_tos(),
2503
2639
&domain_handle,
2504
2640
SAMR_USER_ACCESS_GET_GROUPS,
2505
rid.ids[0], &user_handle);
2641
rid.ids[0], &user_handle,
2506
2643
if (!NT_STATUS_IS_OK(status)) {
2507
2644
DEBUG(0, ("api_RNetUserEnum: samr_LookupNames failed: %s\n",
2508
2645
nt_errstr(status)));
2509
2646
goto close_domain;
2648
if (!NT_STATUS_IS_OK(result)) {
2649
DEBUG(0, ("api_RNetUserEnum: samr_LookupNames failed: %s\n",
2650
nt_errstr(result)));
2512
status = rpccli_samr_GetGroupsForUser(samr_pipe, talloc_tos(),
2513
&user_handle, &rids);
2654
status = dcerpc_samr_GetGroupsForUser(b, talloc_tos(),
2655
&user_handle, &rids,
2514
2657
if (!NT_STATUS_IS_OK(status)) {
2515
2658
DEBUG(0, ("api_RNetUserEnum: samr_LookupNames failed: %s\n",
2516
2659
nt_errstr(status)));
2662
if (!NT_STATUS_IS_OK(result)) {
2663
DEBUG(0, ("api_RNetUserEnum: samr_LookupNames failed: %s\n",
2664
nt_errstr(result)));
2517
2665
goto close_user;
2520
2668
for (i=0; i<rids->count; i++) {
2522
status = rpccli_samr_LookupRids(samr_pipe, talloc_tos(),
2670
status = dcerpc_samr_LookupRids(b, talloc_tos(),
2523
2671
&domain_handle,
2524
2672
1, &rids->rids[i].rid,
2526
if (NT_STATUS_IS_OK(status) && (names.count == 1)) {
2675
if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(result) && (names.count == 1)) {
2527
2676
strlcpy(p, names.names[0].string, PTR_DIFF(endp,p));
2612
2764
endp = *rdata + *rdata_len;
2614
status = rpc_pipe_open_internal(
2615
talloc_tos(), &ndr_table_samr.syntax_id, rpc_samr_dispatch,
2616
conn->server_info, &samr_pipe);
2766
status = rpc_pipe_open_interface(
2767
talloc_tos(), &ndr_table_samr.syntax_id,
2768
conn->session_info, &conn->sconn->client_id,
2769
conn->sconn->msg_ctx, &samr_pipe);
2617
2770
if (!NT_STATUS_IS_OK(status)) {
2618
2771
DEBUG(0, ("api_RNetUserEnum: Could not connect to samr: %s\n",
2619
2772
nt_errstr(status)));
2623
status = rpccli_samr_Connect2(samr_pipe, talloc_tos(), global_myname(),
2624
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle);
2776
b = samr_pipe->binding_handle;
2778
status = dcerpc_samr_Connect2(b, talloc_tos(), global_myname(),
2779
SAMR_ACCESS_LOOKUP_DOMAIN, &samr_handle,
2625
2781
if (!NT_STATUS_IS_OK(status)) {
2626
2782
DEBUG(0, ("api_RNetUserEnum: samr_Connect2 failed: %s\n",
2627
2783
nt_errstr(status)));
2786
if (!NT_STATUS_IS_OK(result)) {
2787
DEBUG(0, ("api_RNetUserEnum: samr_Connect2 failed: %s\n",
2788
nt_errstr(result)));
2631
status = rpccli_samr_OpenDomain(samr_pipe, talloc_tos(), &samr_handle,
2792
status = dcerpc_samr_OpenDomain(b, talloc_tos(), &samr_handle,
2632
2793
SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS,
2633
get_global_sam_sid(), &domain_handle);
2794
get_global_sam_sid(), &domain_handle,
2634
2796
if (!NT_STATUS_IS_OK(status)) {
2635
2797
DEBUG(0, ("api_RNetUserEnum: samr_OpenDomain failed: %s\n",
2636
2798
nt_errstr(status)));
2637
rpccli_samr_Close(samr_pipe, talloc_tos(), &samr_handle);
2799
dcerpc_samr_Close(b, talloc_tos(), &samr_handle, &result);
2802
if (!NT_STATUS_IS_OK(result)) {
2803
DEBUG(0, ("api_RNetUserEnum: samr_OpenDomain failed: %s\n",
2804
nt_errstr(result)));
2805
dcerpc_samr_Close(b, talloc_tos(), &samr_handle, &result);
2819
3023
*rdata_len = 0;
2821
SSVAL(*rparam,0,NERR_badpass);
2822
SSVAL(*rparam,2,0); /* converter word */
2824
DEBUG(3,("Set password for <%s>\n",user));
2827
* Attempt to verify the old password against smbpasswd entries
2828
* Win98 clients send old and new password in plaintext for this call.
2832
auth_serversupplied_info *server_info = NULL;
2833
DATA_BLOB password = data_blob(pass1, strlen(pass1)+1);
2835
if (NT_STATUS_IS_OK(check_plaintext_password(user,password,&server_info))) {
2838
if (NT_STATUS_IS_OK(change_oem_password(server_info->sam_account, pass1, pass2, False, NULL))) {
2839
SSVAL(*rparam,0,NERR_Success);
2843
TALLOC_FREE(server_info);
2845
data_blob_clear_free(&password);
2849
* If the plaintext change failed, attempt
2850
* the old encrypted method. NT will generate this
2851
* after trying the samr method. Note that this
2852
* method is done as a last resort as this
2853
* password change method loses the NT password hash
2854
* and cannot change the UNIX password as no plaintext
2858
if(SVAL(*rparam,0) != NERR_Success) {
2859
struct samu *hnd = NULL;
2861
if (check_lanman_password(user,(unsigned char *)pass1,(unsigned char *)pass2, &hnd)) {
2863
if (change_lanman_password(hnd,(uchar *)pass2)) {
2864
SSVAL(*rparam,0,NERR_Success);
3025
DEBUG(3,("Set password for <%s> (encrypted: %d, min_pwd_length: %d)\n",
3026
user, encrypted, min_pwd_length));
3028
ZERO_STRUCT(connect_handle);
3029
ZERO_STRUCT(domain_handle);
3030
ZERO_STRUCT(user_handle);
3032
status = rpc_pipe_open_interface(mem_ctx, &ndr_table_samr.syntax_id,
3034
&conn->sconn->client_id,
3035
conn->sconn->msg_ctx,
3037
if (!NT_STATUS_IS_OK(status)) {
3038
DEBUG(0,("api_SetUserPassword: could not connect to samr: %s\n",
3039
nt_errstr(status)));
3040
errcode = W_ERROR_V(ntstatus_to_werror(status));
3044
b = cli->binding_handle;
3046
status = dcerpc_samr_Connect2(b, mem_ctx,
3048
SAMR_ACCESS_CONNECT_TO_SERVER |
3049
SAMR_ACCESS_ENUM_DOMAINS |
3050
SAMR_ACCESS_LOOKUP_DOMAIN,
3053
if (!NT_STATUS_IS_OK(status)) {
3054
errcode = W_ERROR_V(ntstatus_to_werror(status));
3057
if (!NT_STATUS_IS_OK(result)) {
3058
errcode = W_ERROR_V(ntstatus_to_werror(result));
3062
init_lsa_String(&domain_name, get_global_sam_name());
3064
status = dcerpc_samr_LookupDomain(b, mem_ctx,
3069
if (!NT_STATUS_IS_OK(status)) {
3070
errcode = W_ERROR_V(ntstatus_to_werror(status));
3073
if (!NT_STATUS_IS_OK(result)) {
3074
errcode = W_ERROR_V(ntstatus_to_werror(result));
3078
status = dcerpc_samr_OpenDomain(b, mem_ctx,
3080
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
3084
if (!NT_STATUS_IS_OK(status)) {
3085
errcode = W_ERROR_V(ntstatus_to_werror(status));
3088
if (!NT_STATUS_IS_OK(result)) {
3089
errcode = W_ERROR_V(ntstatus_to_werror(result));
3093
init_lsa_String(&names, user);
3095
status = dcerpc_samr_LookupNames(b, mem_ctx,
3102
if (!NT_STATUS_IS_OK(status)) {
3103
errcode = W_ERROR_V(ntstatus_to_werror(status));
3106
if (!NT_STATUS_IS_OK(result)) {
3107
errcode = W_ERROR_V(ntstatus_to_werror(result));
3111
if (rids.count != 1) {
3112
errcode = W_ERROR_V(WERR_NO_SUCH_USER);
3115
if (rids.count != types.count) {
3116
errcode = W_ERROR_V(WERR_INVALID_PARAM);
3119
if (types.ids[0] != SID_NAME_USER) {
3120
errcode = W_ERROR_V(WERR_INVALID_PARAM);
3126
status = dcerpc_samr_OpenUser(b, mem_ctx,
3128
SAMR_USER_ACCESS_CHANGE_PASSWORD,
3132
if (!NT_STATUS_IS_OK(status)) {
3133
errcode = W_ERROR_V(ntstatus_to_werror(status));
3136
if (!NT_STATUS_IS_OK(result)) {
3137
errcode = W_ERROR_V(ntstatus_to_werror(result));
3141
if (encrypted == 0) {
3142
E_deshash(pass1, old_lm_hash.hash);
3143
E_deshash(pass2, new_lm_hash.hash);
3145
ZERO_STRUCT(old_lm_hash);
3146
ZERO_STRUCT(new_lm_hash);
3147
memcpy(old_lm_hash.hash, pass1, MIN(strlen(pass1), 16));
3148
memcpy(new_lm_hash.hash, pass1, MIN(strlen(pass2), 16));
3151
status = dcerpc_samr_ChangePasswordUser(b, mem_ctx,
3153
true, /* lm_present */
3156
false, /* nt_present */
3157
NULL, /* old_nt_crypted */
3158
NULL, /* new_nt_crypted */
3159
false, /* cross1_present */
3160
NULL, /* nt_cross */
3161
false, /* cross2_present */
3162
NULL, /* lm_cross */
3164
if (!NT_STATUS_IS_OK(status)) {
3165
errcode = W_ERROR_V(ntstatus_to_werror(status));
3168
if (!NT_STATUS_IS_OK(result)) {
3169
errcode = W_ERROR_V(ntstatus_to_werror(result));
3173
errcode = NERR_Success;
3176
if (b && is_valid_policy_hnd(&user_handle)) {
3177
dcerpc_samr_Close(b, mem_ctx, &user_handle, &result);
3179
if (b && is_valid_policy_hnd(&domain_handle)) {
3180
dcerpc_samr_Close(b, mem_ctx, &domain_handle, &result);
3182
if (b && is_valid_policy_hnd(&connect_handle)) {
3183
dcerpc_samr_Close(b, mem_ctx, &connect_handle, &result);
2871
3186
memset((char *)pass1,'\0',sizeof(fstring));
2872
memset((char *)pass2,'\0',sizeof(fstring));
3187
memset((char *)pass2,'\0',sizeof(fstring));
3189
SSVAL(*rparam,0,errcode);
3190
SSVAL(*rparam,2,0); /* converter word */
2878
3195
Set the user password (SamOEM version - gets plaintext).
2879
3196
****************************************************************************/
2881
static bool api_SamOEMChangePassword(connection_struct *conn,uint16 vuid,
3198
static bool api_SamOEMChangePassword(struct smbd_server_connection *sconn,
3199
connection_struct *conn,uint16 vuid,
2882
3200
char *param, int tpscnt,
2883
3201
char *data, int tdscnt,
2884
3202
int mdrcnt,int mprcnt,
2885
3203
char **rdata,char **rparam,
2886
3204
int *rdata_len,int *rparam_len)
2888
struct smbd_server_connection *sconn = smbd_server_conn;
2890
3207
char *p = get_safe_str_ptr(param,tpscnt,param,2);
3209
TALLOC_CTX *mem_ctx = talloc_tos();
3210
NTSTATUS status, result;
3211
struct rpc_pipe_client *cli = NULL;
3212
struct lsa_AsciiString server, account;
3213
struct samr_CryptPassword password;
3214
struct samr_Password hash;
3215
int errcode = NERR_badpass;
3217
struct dcerpc_binding_handle *b;
2892
3220
*rparam = smb_realloc_limit(*rparam,*rparam_len);
2893
3221
if (!*rparam) {
2939
3267
DEBUG(3,("api_SamOEMChangePassword: Change password for <%s>\n",user));
2942
* Pass the user through the NT -> unix user mapping
2946
(void)map_username(sconn, user);
2948
if (NT_STATUS_IS_OK(pass_oem_change(user, (uchar*) data, (uchar *)&data[516], NULL, NULL, NULL))) {
2949
SSVAL(*rparam,0,NERR_Success);
3269
if (tdscnt != 532) {
3270
errcode = W_ERROR_V(WERR_INVALID_PARAM);
3274
bufsize = get_safe_SVAL(param,tpscnt,p,0,-1);
3275
if (bufsize != 532) {
3276
errcode = W_ERROR_V(WERR_INVALID_PARAM);
3280
memcpy(password.data, data, 516);
3281
memcpy(hash.hash, data+516, 16);
3283
status = rpc_pipe_open_interface(mem_ctx, &ndr_table_samr.syntax_id,
3285
&conn->sconn->client_id,
3286
conn->sconn->msg_ctx,
3288
if (!NT_STATUS_IS_OK(status)) {
3289
DEBUG(0,("api_SamOEMChangePassword: could not connect to samr: %s\n",
3290
nt_errstr(status)));
3291
errcode = W_ERROR_V(ntstatus_to_werror(status));
3295
b = cli->binding_handle;
3297
init_lsa_AsciiString(&server, global_myname());
3298
init_lsa_AsciiString(&account, user);
3300
status = dcerpc_samr_OemChangePasswordUser2(b, mem_ctx,
3306
if (!NT_STATUS_IS_OK(status)) {
3307
errcode = W_ERROR_V(ntstatus_to_werror(status));
3310
if (!NT_STATUS_IS_OK(result)) {
3311
errcode = W_ERROR_V(ntstatus_to_werror(result));
3315
errcode = NERR_Success;
3317
SSVAL(*rparam,0,errcode);
3318
SSVAL(*rparam,2,0); /* converter word */
2955
3323
/****************************************************************************
2956
3324
delete a print job
2958
3326
****************************************************************************/
2960
static bool api_RDosPrintJobDel(connection_struct *conn,uint16 vuid,
3328
static bool api_RDosPrintJobDel(struct smbd_server_connection *sconn,
3329
connection_struct *conn,uint16 vuid,
2961
3330
char *param, int tpscnt,
2962
3331
char *data, int tdscnt,
2963
3332
int mdrcnt,int mprcnt,
2999
3375
*rdata_len = 0;
3001
if (!print_job_exists(sharename, jobid)) {
3002
errcode = NERR_JobNotFound;
3006
snum = lp_servicenumber( sharename);
3008
errcode = NERR_DestNotFound;
3012
errcode = NERR_notsupported;
3377
ZERO_STRUCT(handle);
3379
status = rpc_pipe_open_interface(conn,
3380
&ndr_table_spoolss.syntax_id,
3382
&conn->sconn->client_id,
3383
conn->sconn->msg_ctx,
3385
if (!NT_STATUS_IS_OK(status)) {
3386
DEBUG(0,("api_RDosPrintJobDel: could not connect to spoolss: %s\n",
3387
nt_errstr(status)));
3388
errcode = W_ERROR_V(ntstatus_to_werror(status));
3391
b = cli->binding_handle;
3393
ZERO_STRUCT(devmode_ctr);
3395
status = dcerpc_spoolss_OpenPrinter(b, mem_ctx,
3399
JOB_ACCESS_ADMINISTER,
3402
if (!NT_STATUS_IS_OK(status)) {
3403
errcode = W_ERROR_V(ntstatus_to_werror(status));
3406
if (!W_ERROR_IS_OK(werr)) {
3407
errcode = W_ERROR_V(werr);
3411
/* FIXME: formerly NERR_JobNotFound was returned if job did not exist
3412
* and NERR_DestNotFound if share did not exist */
3414
errcode = NERR_Success;
3014
3416
switch (function) {
3015
case 81: /* delete */
3016
if (print_job_delete(conn->server_info, snum, jobid, &werr))
3017
errcode = NERR_Success;
3417
case 81: /* delete */
3418
command = SPOOLSS_JOB_CONTROL_DELETE;
3019
3420
case 82: /* pause */
3020
if (print_job_pause(conn->server_info, snum, jobid, &werr))
3021
errcode = NERR_Success;
3421
command = SPOOLSS_JOB_CONTROL_PAUSE;
3023
3423
case 83: /* resume */
3024
if (print_job_resume(conn->server_info, snum, jobid, &werr))
3025
errcode = NERR_Success;
3424
command = SPOOLSS_JOB_CONTROL_RESUME;
3427
errcode = NERR_notsupported;
3029
if (!W_ERROR_IS_OK(werr))
3431
status = dcerpc_spoolss_SetJob(b, mem_ctx,
3434
NULL, /* unique ptr ctr */
3437
if (!NT_STATUS_IS_OK(status)) {
3438
errcode = W_ERROR_V(ntstatus_to_werror(status));
3441
if (!W_ERROR_IS_OK(werr)) {
3030
3442
errcode = W_ERROR_V(werr);
3033
SSVAL(*rparam,0,errcode);
3447
if (b && is_valid_policy_hnd(&handle)) {
3448
dcerpc_spoolss_ClosePrinter(b, mem_ctx, &handle, &werr);
3451
SSVAL(*rparam,0,errcode);
3034
3452
SSVAL(*rparam,2,0); /* converter word */
3073
3501
if (skip_string(param,tpscnt,QueueName) == NULL) {
3076
snum = print_queue_snum(QueueName);
3079
errcode = NERR_JobNotFound;
3505
ZERO_STRUCT(handle);
3507
status = rpc_pipe_open_interface(conn,
3508
&ndr_table_spoolss.syntax_id,
3510
&conn->sconn->client_id,
3511
conn->sconn->msg_ctx,
3513
if (!NT_STATUS_IS_OK(status)) {
3514
DEBUG(0,("api_WPrintQueueCtrl: could not connect to spoolss: %s\n",
3515
nt_errstr(status)));
3516
errcode = W_ERROR_V(ntstatus_to_werror(status));
3519
b = cli->binding_handle;
3521
ZERO_STRUCT(devmode_ctr);
3523
status = dcerpc_spoolss_OpenPrinter(b, mem_ctx,
3527
SEC_FLAG_MAXIMUM_ALLOWED,
3530
if (!NT_STATUS_IS_OK(status)) {
3531
errcode = W_ERROR_V(ntstatus_to_werror(status));
3534
if (!W_ERROR_IS_OK(werr)) {
3535
errcode = W_ERROR_V(werr);
3083
3539
switch (function) {
3084
3540
case 74: /* Pause queue */
3085
werr = print_queue_pause(conn->server_info, snum);
3541
command = SPOOLSS_PRINTER_CONTROL_PAUSE;
3087
3543
case 75: /* Resume queue */
3088
werr = print_queue_resume(conn->server_info, snum);
3544
command = SPOOLSS_PRINTER_CONTROL_RESUME;
3090
3546
case 103: /* Purge */
3091
werr = print_queue_purge(conn->server_info, snum);
3547
command = SPOOLSS_PRINTER_CONTROL_PURGE;
3094
3550
werr = WERR_NOT_SUPPORTED;
3554
if (!W_ERROR_IS_OK(werr)) {
3555
errcode = W_ERROR_V(werr);
3559
ZERO_STRUCT(info_ctr);
3560
ZERO_STRUCT(secdesc_ctr);
3562
status = dcerpc_spoolss_SetPrinter(b, mem_ctx,
3569
if (!NT_STATUS_IS_OK(status)) {
3570
errcode = W_ERROR_V(ntstatus_to_werror(status));
3573
if (!W_ERROR_IS_OK(werr)) {
3574
errcode = W_ERROR_V(werr);
3098
3578
errcode = W_ERROR_V(werr);
3582
if (b && is_valid_policy_hnd(&handle)) {
3583
dcerpc_spoolss_ClosePrinter(b, mem_ctx, &handle, &werr);
3101
3586
SSVAL(*rparam,0,errcode);
3102
3587
SSVAL(*rparam,2,0); /* converter word */
3173
if (!share_defined(sharename)) {
3174
DEBUG(0,("api_PrintJobInfo: sharen [%s] not defined\n",
3179
3670
*rdata_len = 0;
3181
3672
/* check it's a supported varient */
3182
if ((strcmp(str1,"WWsTP")) ||
3673
if ((strcmp(str1,"WWsTP")) ||
3183
3674
(!check_printjob_info(&desc,uLevel,str2)))
3186
if (!print_job_exists(sharename, jobid)) {
3187
errcode=NERR_JobNotFound;
3191
3677
errcode = NERR_notsupported;
3193
3679
switch (function) {
3195
/* change job place in the queue,
3196
data gives the new place */
3197
place = SVAL(data,0);
3198
if (print_job_set_place(sharename, jobid, place)) {
3199
errcode=NERR_Success;
3204
3681
/* change print job name, data gives the name */
3205
if (print_job_set_name(sharename, jobid, data)) {
3206
errcode=NERR_Success;
3687
ZERO_STRUCT(handle);
3689
status = rpc_pipe_open_interface(conn,
3690
&ndr_table_spoolss.syntax_id,
3692
&conn->sconn->client_id,
3693
conn->sconn->msg_ctx,
3695
if (!NT_STATUS_IS_OK(status)) {
3696
DEBUG(0,("api_PrintJobInfo: could not connect to spoolss: %s\n",
3697
nt_errstr(status)));
3698
errcode = W_ERROR_V(ntstatus_to_werror(status));
3701
b = cli->binding_handle;
3703
ZERO_STRUCT(devmode_ctr);
3705
status = dcerpc_spoolss_OpenPrinter(b, mem_ctx,
3712
if (!NT_STATUS_IS_OK(status)) {
3713
errcode = W_ERROR_V(ntstatus_to_werror(status));
3716
if (!W_ERROR_IS_OK(werr)) {
3717
errcode = W_ERROR_V(werr);
3721
werr = rpccli_spoolss_getjob(cli, mem_ctx,
3727
if (!W_ERROR_IS_OK(werr)) {
3728
errcode = W_ERROR_V(werr);
3734
info1.job_id = info.info1.job_id;
3735
info1.printer_name = info.info1.printer_name;
3736
info1.user_name = info.info1.user_name;
3737
info1.document_name = data;
3738
info1.data_type = info.info1.data_type;
3739
info1.text_status = info.info1.text_status;
3740
info1.status = info.info1.status;
3741
info1.priority = info.info1.priority;
3742
info1.position = info.info1.position;
3743
info1.total_pages = info.info1.total_pages;
3744
info1.pages_printed = info.info1.pages_printed;
3745
info1.submitted = info.info1.submitted;
3748
ctr.info.info1 = &info1;
3750
status = dcerpc_spoolss_SetJob(b, mem_ctx,
3756
if (!NT_STATUS_IS_OK(status)) {
3757
errcode = W_ERROR_V(ntstatus_to_werror(status));
3760
if (!W_ERROR_IS_OK(werr)) {
3761
errcode = W_ERROR_V(werr);
3765
errcode = NERR_Success;
3768
if (b && is_valid_policy_hnd(&handle)) {
3769
dcerpc_spoolss_ClosePrinter(b, mem_ctx, &handle, &werr);
3215
3772
SSVALS(*rparam,0,errcode);
3216
3773
SSVAL(*rparam,2,0); /* converter word */
3299
3865
p2 = p + struct_len;
3867
status = rpc_pipe_open_interface(mem_ctx, &ndr_table_srvsvc.syntax_id,
3869
&conn->sconn->client_id,
3870
conn->sconn->msg_ctx,
3872
if (!NT_STATUS_IS_OK(status)) {
3873
DEBUG(0,("api_RNetServerGetInfo: could not connect to srvsvc: %s\n",
3874
nt_errstr(status)));
3875
errcode = W_ERROR_V(ntstatus_to_werror(status));
3879
b = cli->binding_handle;
3881
status = dcerpc_srvsvc_NetSrvGetInfo(b, mem_ctx,
3886
if (!NT_STATUS_IS_OK(status)) {
3887
errcode = W_ERROR_V(ntstatus_to_werror(status));
3890
if (!W_ERROR_IS_OK(werr)) {
3891
errcode = W_ERROR_V(werr);
3895
if (info.info101 == NULL) {
3896
errcode = W_ERROR_V(WERR_INVALID_PARAM);
3300
3900
if (uLevel != 20) {
3301
srvstr_push(NULL, 0, p,global_myname(),16,
3901
srvstr_push(NULL, 0, p, info.info101->server_name, 16,
3302
3902
STR_ASCII|STR_UPPER|STR_TERMINATE);
3305
3905
if (uLevel > 0) {
3306
struct srv_info_struct *servers=NULL;
3308
char *comment = NULL;
3309
TALLOC_CTX *ctx = talloc_tos();
3310
uint32 servertype= lp_default_server_announce();
3312
comment = talloc_strdup(ctx,lp_serverstring());
3317
if ((count=get_server_info(SV_TYPE_ALL,&servers,lp_workgroup()))>0) {
3318
for (i=0;i<count;i++) {
3319
if (strequal(servers[i].name,global_myname())) {
3320
servertype = servers[i].type;
3321
TALLOC_FREE(comment);
3322
comment = talloc_strdup(ctx,
3323
servers[i].comment);
3333
SCVAL(p,0,lp_major_announce_version());
3334
SCVAL(p,1,lp_minor_announce_version());
3335
SIVAL(p,2,servertype);
3906
SCVAL(p,0,info.info101->version_major);
3907
SCVAL(p,1,info.info101->version_minor);
3908
SIVAL(p,2,info.info101->server_type);
3337
3910
if (mdrcnt == struct_len) {
3340
3913
SIVAL(p,6,PTR_DIFF(p2,*rdata));
3341
comment = talloc_sub_advanced(
3343
lp_servicename(SNUM(conn)),
3344
conn->server_info->unix_name,
3346
conn->server_info->utok.gid,
3347
conn->server_info->sanitized_username,
3348
pdb_get_domain(conn->server_info->sam_account),
3353
3914
if (mdrcnt - struct_len <= 0) {
3918
info.info101->comment,
3358
3919
MIN(mdrcnt - struct_len,
3359
3920
MAX_SERVER_STRING_LENGTH),
3360
3921
STR_TERMINATE);
4290
ZERO_STRUCT(connect_handle);
4291
ZERO_STRUCT(domain_handle);
4292
ZERO_STRUCT(user_handle);
4294
status = rpc_pipe_open_interface(mem_ctx, &ndr_table_samr.syntax_id,
4296
&conn->sconn->client_id,
4297
conn->sconn->msg_ctx,
4299
if (!NT_STATUS_IS_OK(status)) {
4300
DEBUG(0,("api_RNetUserGetInfo: could not connect to samr: %s\n",
4301
nt_errstr(status)));
4302
errcode = W_ERROR_V(ntstatus_to_werror(status));
4306
b = cli->binding_handle;
4308
status = dcerpc_samr_Connect2(b, mem_ctx,
4310
SAMR_ACCESS_CONNECT_TO_SERVER |
4311
SAMR_ACCESS_ENUM_DOMAINS |
4312
SAMR_ACCESS_LOOKUP_DOMAIN,
4315
if (!NT_STATUS_IS_OK(status)) {
4316
errcode = W_ERROR_V(ntstatus_to_werror(status));
4319
if (!NT_STATUS_IS_OK(result)) {
4320
errcode = W_ERROR_V(ntstatus_to_werror(result));
4324
init_lsa_String(&domain_name, get_global_sam_name());
4326
status = dcerpc_samr_LookupDomain(b, mem_ctx,
4331
if (!NT_STATUS_IS_OK(status)) {
4332
errcode = W_ERROR_V(ntstatus_to_werror(status));
4335
if (!NT_STATUS_IS_OK(result)) {
4336
errcode = W_ERROR_V(ntstatus_to_werror(result));
4340
status = dcerpc_samr_OpenDomain(b, mem_ctx,
4342
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
4346
if (!NT_STATUS_IS_OK(status)) {
4347
errcode = W_ERROR_V(ntstatus_to_werror(status));
4350
if (!NT_STATUS_IS_OK(result)) {
4351
errcode = W_ERROR_V(ntstatus_to_werror(result));
4355
init_lsa_String(&names, UserName);
4357
status = dcerpc_samr_LookupNames(b, mem_ctx,
4364
if (!NT_STATUS_IS_OK(status)) {
4365
errcode = W_ERROR_V(ntstatus_to_werror(status));
4368
if (!NT_STATUS_IS_OK(result)) {
4369
errcode = W_ERROR_V(ntstatus_to_werror(result));
4373
if (rids.count != 1) {
4374
errcode = W_ERROR_V(WERR_NO_SUCH_USER);
4377
if (rids.count != types.count) {
4378
errcode = W_ERROR_V(WERR_INVALID_PARAM);
4381
if (types.ids[0] != SID_NAME_USER) {
4382
errcode = W_ERROR_V(WERR_INVALID_PARAM);
4388
status = dcerpc_samr_OpenUser(b, mem_ctx,
4390
SAMR_USER_ACCESS_GET_LOCALE |
4391
SAMR_USER_ACCESS_GET_LOGONINFO |
4392
SAMR_USER_ACCESS_GET_ATTRIBUTES |
4393
SAMR_USER_ACCESS_GET_GROUPS |
4394
SAMR_USER_ACCESS_GET_GROUP_MEMBERSHIP |
4395
SEC_STD_READ_CONTROL,
4399
if (!NT_STATUS_IS_OK(status)) {
4400
errcode = W_ERROR_V(ntstatus_to_werror(status));
4403
if (!NT_STATUS_IS_OK(result)) {
4404
errcode = W_ERROR_V(ntstatus_to_werror(result));
4408
status = dcerpc_samr_QueryUserInfo2(b, mem_ctx,
4413
if (!NT_STATUS_IS_OK(status)) {
4414
errcode = W_ERROR_V(ntstatus_to_werror(status));
4417
if (!NT_STATUS_IS_OK(result)) {
4418
errcode = W_ERROR_V(ntstatus_to_werror(result));
3733
4422
memset(p,0,21);
3734
4423
fstrcpy(p+usri11_name,UserName); /* 21 bytes - user name */
3838
4523
SSVAL(p,52,0); /* flags */
3839
4524
SIVAL(p,54,PTR_DIFF(p2,*rdata)); /* script_path */
3840
strlcpy(p2, vuser ? pdb_get_logon_script(
3841
vuser->server_info->sam_account) : "",
4525
strlcpy(p2, info->info21.logon_script.string,
3842
4526
PTR_DIFF(endp,p2));
3843
4527
p2 = skip_string(*rdata,*rdata_len,p2);
3847
4531
if (uLevel == 2) {
3848
SIVAL(p,60,0); /* auth_flags */
3849
SIVAL(p,64,PTR_DIFF(p2,*rdata)); /* full_name */
3850
strlcpy(p2,((vuser != NULL)
3851
? pdb_get_fullname(vuser->server_info->sam_account)
3852
: UserName),PTR_DIFF(endp,p2));
4532
SIVAL(p,58,0); /* auth_flags */
4533
SIVAL(p,62,PTR_DIFF(p2,*rdata)); /* full_name */
4534
strlcpy(p2,info->info21.full_name.string,PTR_DIFF(endp,p2));
3853
4535
p2 = skip_string(*rdata,*rdata_len,p2);
3857
SIVAL(p,68,0); /* urs_comment */
3858
SIVAL(p,72,PTR_DIFF(p2,*rdata)); /* parms */
4539
SIVAL(p,66,0); /* urs_comment */
4540
SIVAL(p,70,PTR_DIFF(p2,*rdata)); /* parms */
3859
4541
strlcpy(p2,"",PTR_DIFF(endp,p2));
3860
4542
p2 = skip_string(*rdata,*rdata_len,p2);
3864
SIVAL(p,76,0); /* workstations */
3865
SIVAL(p,80,0); /* last_logon */
3866
SIVAL(p,84,0); /* last_logoff */
3867
SIVALS(p,88,-1); /* acct_expires */
3868
SIVALS(p,92,-1); /* max_storage */
3869
SSVAL(p,96,168); /* units_per_week */
3870
SIVAL(p,98,PTR_DIFF(p2,*rdata)); /* logon_hours */
4546
SIVAL(p,74,0); /* workstations */
4547
SIVAL(p,78,0); /* last_logon */
4548
SIVAL(p,82,0); /* last_logoff */
4549
SIVALS(p,86,-1); /* acct_expires */
4550
SIVALS(p,90,-1); /* max_storage */
4551
SSVAL(p,94,168); /* units_per_week */
4552
SIVAL(p,96,PTR_DIFF(p2,*rdata)); /* logon_hours */
3871
4553
memset(p2,-1,21);
3873
SSVALS(p,102,-1); /* bad_pw_count */
3874
SSVALS(p,104,-1); /* num_logons */
3875
SIVAL(p,106,PTR_DIFF(p2,*rdata)); /* logon_server */
4555
SSVALS(p,100,-1); /* bad_pw_count */
4556
SSVALS(p,102,-1); /* num_logons */
4557
SIVAL(p,104,PTR_DIFF(p2,*rdata)); /* logon_server */
3877
4559
TALLOC_CTX *ctx = talloc_tos();
3878
4560
int space_rem = *rdata_len - (p2 - *rdata);
3905
SSVAL(p,110,49); /* country_code */
3906
SSVAL(p,112,860); /* code page */
4587
SSVAL(p,108,49); /* country_code */
4588
SSVAL(p,110,860); /* code page */
4592
errcode = NERR_Success;
3910
4595
*rdata_len = PTR_DIFF(p2,*rdata);
4597
if (b && is_valid_policy_hnd(&user_handle)) {
4598
dcerpc_samr_Close(b, mem_ctx, &user_handle, &result);
4600
if (b && is_valid_policy_hnd(&domain_handle)) {
4601
dcerpc_samr_Close(b, mem_ctx, &domain_handle, &result);
4603
if (b && is_valid_policy_hnd(&connect_handle)) {
4604
dcerpc_samr_Close(b, mem_ctx, &connect_handle, &result);
4607
SSVAL(*rparam,0,errcode);
4608
SSVAL(*rparam,2,0); /* converter word */
3912
4609
SSVAL(*rparam,4,*rdata_len); /* is this right?? */
3917
static bool api_WWkstaUserLogon(connection_struct *conn,uint16 vuid,
4614
static bool api_WWkstaUserLogon(struct smbd_server_connection *sconn,
4615
connection_struct *conn,uint16 vuid,
3918
4616
char *param, int tpscnt,
3919
4617
char *data, int tdscnt,
3920
4618
int mdrcnt,int mprcnt,
3921
4619
char **rdata,char **rparam,
3922
4620
int *rdata_len,int *rparam_len)
3924
struct smbd_server_connection *sconn = smbd_server_conn;
3925
4622
char *str1 = get_safe_str_ptr(param,tpscnt,param,2);
3926
4623
char *str2 = skip_string(param,tpscnt,str1);
3927
4624
char *p = skip_string(param,tpscnt,str2);
4112
snum = lp_servicenumber( sharename);
4113
if (snum < 0 || !VALID_SNUM(snum)) {
4117
count = print_queue_status(snum,&queue,&status);
4118
for (i = 0; i < count; i++) {
4119
if (queue[i].job == jobid) {
4818
ZERO_STRUCT(handle);
4820
status = rpc_pipe_open_interface(conn,
4821
&ndr_table_spoolss.syntax_id,
4823
&conn->sconn->client_id,
4824
conn->sconn->msg_ctx,
4826
if (!NT_STATUS_IS_OK(status)) {
4827
DEBUG(0,("api_WPrintJobGetInfo: could not connect to spoolss: %s\n",
4828
nt_errstr(status)));
4829
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
4832
b = cli->binding_handle;
4834
ZERO_STRUCT(devmode_ctr);
4836
status = dcerpc_spoolss_OpenPrinter(b, mem_ctx,
4843
if (!NT_STATUS_IS_OK(status)) {
4844
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
4847
if (!W_ERROR_IS_OK(werr)) {
4848
desc.errcode = W_ERROR_V(werr);
4852
werr = rpccli_spoolss_getjob(cli, mem_ctx,
4858
if (!W_ERROR_IS_OK(werr)) {
4859
desc.errcode = W_ERROR_V(werr);
4124
4863
if (mdrcnt > 0) {
4207
4953
return False; /* defined only for uLevel 0,1,2 */
4210
if (!check_printjob_info(&desc,uLevel,str2)) {
4214
snum = find_service(name);
4215
if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) ) {
4219
count = print_queue_status(snum,&queue,&status);
4956
if (!check_printjob_info(&desc,uLevel,str2)) {
4960
ZERO_STRUCT(handle);
4962
status = rpc_pipe_open_interface(conn,
4963
&ndr_table_spoolss.syntax_id,
4965
&conn->sconn->client_id,
4966
conn->sconn->msg_ctx,
4968
if (!NT_STATUS_IS_OK(status)) {
4969
DEBUG(0,("api_WPrintJobEnumerate: could not connect to spoolss: %s\n",
4970
nt_errstr(status)));
4971
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
4974
b = cli->binding_handle;
4976
ZERO_STRUCT(devmode_ctr);
4978
status = dcerpc_spoolss_OpenPrinter(b, mem_ctx,
4982
SEC_FLAG_MAXIMUM_ALLOWED,
4985
if (!NT_STATUS_IS_OK(status)) {
4986
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
4989
if (!W_ERROR_IS_OK(werr)) {
4990
desc.errcode = W_ERROR_V(werr);
4994
werr = rpccli_spoolss_enumjobs(cli, mem_ctx,
5002
if (!W_ERROR_IS_OK(werr)) {
5003
desc.errcode = W_ERROR_V(werr);
4220
5007
if (mdrcnt > 0) {
4221
5008
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4362
snum = find_service(PrinterName);
4363
if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) ) {
4365
desc.errcode = NERR_DestNotFound;
5160
ZERO_STRUCT(handle);
5162
status = rpc_pipe_open_interface(conn,
5163
&ndr_table_spoolss.syntax_id,
5165
&conn->sconn->client_id,
5166
conn->sconn->msg_ctx,
5168
if (!NT_STATUS_IS_OK(status)) {
5169
DEBUG(0,("api_WPrintDestGetInfo: could not connect to spoolss: %s\n",
5170
nt_errstr(status)));
5171
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
5174
b = cli->binding_handle;
5176
ZERO_STRUCT(devmode_ctr);
5178
status = dcerpc_spoolss_OpenPrinter(b, mem_ctx,
5182
SEC_FLAG_MAXIMUM_ALLOWED,
5185
if (!NT_STATUS_IS_OK(status)) {
5187
desc.errcode = NERR_DestNotFound;
5191
if (!W_ERROR_IS_OK(werr)) {
5193
desc.errcode = NERR_DestNotFound;
5198
werr = rpccli_spoolss_getprinter(cli, mem_ctx,
5203
if (!W_ERROR_IS_OK(werr)) {
5205
desc.errcode = NERR_DestNotFound;
5211
*rdata = smb_realloc_limit(*rdata,mdrcnt);
5216
desc.buflen = mdrcnt;
4369
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4374
desc.buflen = mdrcnt;
4377
* Don't return data but need to get correct length
4378
* init_package will return wrong size if buflen=0
4380
desc.buflen = getlen(desc.format);
4381
desc.base = tmpdata = (char *)SMB_MALLOC( desc.buflen );
4383
if (init_package(&desc,1,0)) {
4384
fill_printdest_info(conn,snum,uLevel,&desc);
4386
*rdata_len = desc.usedlen;
5219
* Don't return data but need to get correct length
5220
* init_package will return wrong size if buflen=0
5222
desc.buflen = getlen(desc.format);
5223
desc.base = tmpdata = (char *)SMB_MALLOC( desc.buflen );
5225
if (init_package(&desc,1,0)) {
5226
fill_printdest_info(&info.info2, uLevel,&desc);
5230
if (b && is_valid_policy_hnd(&handle)) {
5231
dcerpc_spoolss_ClosePrinter(b, mem_ctx, &handle, &werr);
5234
*rdata_len = desc.usedlen;
4389
5236
*rparam_len = 6;
4390
5237
*rparam = smb_realloc_limit(*rparam,*rparam_len);
4716
num_sessions = list_sessions(talloc_tos(), &session_list);
5605
status = rpc_pipe_open_interface(conn,
5606
&ndr_table_srvsvc.syntax_id,
5608
&conn->sconn->client_id,
5609
conn->sconn->msg_ctx,
5611
if (!NT_STATUS_IS_OK(status)) {
5612
DEBUG(0,("RNetSessionEnum: could not connect to srvsvc: %s\n",
5613
nt_errstr(status)));
5614
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
5617
b = cli->binding_handle;
5620
info_ctr.ctr.ctr1 = talloc_zero(talloc_tos(), struct srvsvc_NetSessCtr1);
5621
if (info_ctr.ctr.ctr1 == NULL) {
5622
desc.errcode = W_ERROR_V(WERR_NOMEM);
5626
status = dcerpc_srvsvc_NetSessEnum(b, mem_ctx,
5627
cli->srv_name_slash,
5631
(uint32_t)-1, /* max_buffer */
5635
if (!NT_STATUS_IS_OK(status)) {
5636
DEBUG(0,("RNetSessionEnum: dcerpc_srvsvc_NetSessEnum failed: %s\n",
5637
nt_errstr(status)));
5638
desc.errcode = W_ERROR_V(ntstatus_to_werror(status));
5642
if (!W_ERROR_IS_OK(werr)) {
5643
DEBUG(0,("RNetSessionEnum: dcerpc_srvsvc_NetSessEnum failed: %s\n",
5645
desc.errcode = W_ERROR_V(werr);
5649
count = info_ctr.ctr.ctr1->count;
4718
5652
if (mdrcnt > 0) {
4719
5653
*rdata = smb_realloc_limit(*rdata,mdrcnt);
4724
memset((char *)&desc,'\0',sizeof(desc));
4725
5659
desc.base = *rdata;
4726
5660
desc.buflen = mdrcnt;
4727
5661
desc.format = str2;
4728
if (!init_package(&desc,num_sessions,0)) {
5662
if (!init_package(&desc, count,0)) {
4732
for(i=0; i<num_sessions; i++) {
4733
PACKS(&desc, "z", session_list[i].remote_machine);
4734
PACKS(&desc, "z", session_list[i].username);
5666
for(i=0; i < count; i++) {
5667
PACKS(&desc, "z", info_ctr.ctr.ctr1->array[i].client);
5668
PACKS(&desc, "z", info_ctr.ctr.ctr1->array[i].user);
4735
5669
PACKI(&desc, "W", 1); /* num conns */
4736
PACKI(&desc, "W", 0); /* num opens */
5670
PACKI(&desc, "W", info_ctr.ctr.ctr1->array[i].num_open);
4737
5671
PACKI(&desc, "W", 1); /* num users */
4738
5672
PACKI(&desc, "D", 0); /* session time */
4739
5673
PACKI(&desc, "D", 0); /* idle time */
added
removed
source3/smbd/lanman.c
