rpc_client/cli_spoolss.c

ソースコードを見る。

関数

static BOOL decode_printer_info_0 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, PRINTER_INFO_0 **info)
static BOOL decode_printer_info_1 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, PRINTER_INFO_1 **info)
static BOOL decode_printer_info_2 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, PRINTER_INFO_2 **info)
static BOOL decode_printer_info_3 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, PRINTER_INFO_3 **info)
static BOOL decode_printer_info_7 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, PRINTER_INFO_7 **info)
static BOOL decode_port_info_1 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, PORT_INFO_1 **info)
static BOOL decode_port_info_2 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, PORT_INFO_2 **info)
static BOOL decode_printer_driver_1 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, DRIVER_INFO_1 **info)
static BOOL decode_printer_driver_2 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, DRIVER_INFO_2 **info)
static BOOL decode_printer_driver_3 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, DRIVER_INFO_3 **info)
static BOOL decode_printerdriverdir_1 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 returned, DRIVER_DIRECTORY_1 **info)
static BOOL decode_jobs_1 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 num_jobs, JOB_INFO_1 **jobs)
static BOOL decode_jobs_2 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 num_jobs, JOB_INFO_2 **jobs)
static BOOL decode_forms_1 (TALLOC_CTX *mem_ctx, RPC_BUFFER *buffer, uint32 num_forms, FORM_1 **forms)
WERROR rpccli_spoolss_open_printer_ex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *printername, const char *datatype, uint32 access_required, const char *station, const char *username, POLICY_HND *pol)
WERROR rpccli_spoolss_close_printer (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *pol)
WERROR rpccli_spoolss_enum_printers (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, char *name, uint32 flags, uint32 level, uint32 *num_printers, PRINTER_INFO_CTR *ctr)
WERROR rpccli_spoolss_enum_ports (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32 level, uint32 *num_ports, PORT_INFO_CTR *ctr)
WERROR rpccli_spoolss_getprinter (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *pol, uint32 level, PRINTER_INFO_CTR *ctr)
WERROR rpccli_spoolss_setprinter (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *pol, uint32 level, PRINTER_INFO_CTR *ctr, uint32 command)
WERROR rpccli_spoolss_getprinterdriver (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *pol, uint32 level, const char *env, int version, PRINTER_DRIVER_CTR *ctr)
WERROR rpccli_spoolss_enumprinterdrivers (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32 level, const char *env, uint32 *num_drivers, PRINTER_DRIVER_CTR *ctr)
WERROR rpccli_spoolss_getprinterdriverdir (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32 level, char *env, DRIVER_DIRECTORY_CTR *ctr)
WERROR rpccli_spoolss_addprinterdriver (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32 level, PRINTER_DRIVER_CTR *ctr)
WERROR rpccli_spoolss_addprinterex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32 level, PRINTER_INFO_CTR *ctr)
WERROR rpccli_spoolss_deleteprinterdriverex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *arch, const char *driver, int version)
WERROR rpccli_spoolss_deleteprinterdriver (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *arch, const char *driver)
WERROR rpccli_spoolss_getprintprocessordirectory (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, char *name, char *environment, fstring procdir)
WERROR rpccli_spoolss_addform (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *handle, uint32 level, FORM *form)
WERROR rpccli_spoolss_setform (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *handle, uint32 level, const char *form_name, FORM *form)
WERROR rpccli_spoolss_getform (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *handle, const char *formname, uint32 level, FORM_1 *form)
WERROR rpccli_spoolss_deleteform (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *handle, const char *form_name)
WERROR rpccli_spoolss_enumforms (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *handle, int level, uint32 *num_forms, FORM_1 **forms)
WERROR rpccli_spoolss_enumjobs (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 level, uint32 firstjob, uint32 num_jobs, uint32 *returned, JOB_INFO_CTR *ctr)
WERROR rpccli_spoolss_setjob (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 jobid, uint32 level, uint32 command)
WERROR rpccli_spoolss_getjob (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 jobid, uint32 level, JOB_INFO_CTR *ctr)
WERROR rpccli_spoolss_startpageprinter (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd)
WERROR rpccli_spoolss_endpageprinter (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd)
WERROR rpccli_spoolss_startdocprinter (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *docname, char *outputfile, char *datatype, uint32 *jobid)
WERROR rpccli_spoolss_enddocprinter (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd)
WERROR rpccli_spoolss_getprinterdata (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, const char *valuename, REGISTRY_VALUE *value)
WERROR rpccli_spoolss_getprinterdataex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, const char *keyname, const char *valuename, REGISTRY_VALUE *value)
WERROR rpccli_spoolss_setprinterdata (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, REGISTRY_VALUE *value)
WERROR rpccli_spoolss_setprinterdataex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *keyname, REGISTRY_VALUE *value)
WERROR rpccli_spoolss_enumprinterdata (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 ndx, uint32 value_offered, uint32 data_offered, uint32 *value_needed, uint32 *data_needed, REGISTRY_VALUE *value)
WERROR rpccli_spoolss_enumprinterdataex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, const char *keyname, REGVAL_CTR *ctr)
WERROR rpccli_spoolss_writeprinter (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 data_size, char *data, uint32 *num_written)
WERROR rpccli_spoolss_deleteprinterdata (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *valuename)
WERROR rpccli_spoolss_deleteprinterdataex (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *keyname, char *valuename)
WERROR rpccli_spoolss_enumprinterkey (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, const char *keyname, uint16 **keylist, uint32 *len)
WERROR rpccli_spoolss_deleteprinterkey (struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *keyname)


関数

static BOOL decode_printer_info_0 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
PRINTER_INFO_0 **  info 
) [static]

cli_spoolss.c36 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_printer_info_0().

参照元 rpccli_spoolss_enum_printers()rpccli_spoolss_getprinter().

00038 {
00039         uint32 i;
00040         PRINTER_INFO_0  *inf;
00041 
00042         if (returned) {
00043                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_0, returned);
00044                 if (!inf) {
00045                         return False;
00046                 }
00047                 memset(inf, 0, returned*sizeof(PRINTER_INFO_0));
00048         } else {
00049                 inf = NULL;
00050         }
00051 
00052         prs_set_offset(&buffer->prs,0);
00053 
00054         for (i=0; i<returned; i++) {
00055                 if (!smb_io_printer_info_0("", buffer, &inf[i], 0)) {
00056                         return False;
00057                 }
00058         }
00059 
00060         *info=inf;
00061         return True;
00062 }

static BOOL decode_printer_info_1 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
PRINTER_INFO_1 **  info 
) [static]

cli_spoolss.c67 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_printer_info_1().

参照元 rpccli_spoolss_enum_printers()rpccli_spoolss_getprinter().

00069 {
00070         uint32 i;
00071         PRINTER_INFO_1  *inf;
00072 
00073         if (returned) {
00074                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_1, returned);
00075                 if (!inf) {
00076                         return False;
00077                 }
00078                 memset(inf, 0, returned*sizeof(PRINTER_INFO_1));
00079         } else {
00080                 inf = NULL;
00081         }
00082 
00083         prs_set_offset(&buffer->prs,0);
00084 
00085         for (i=0; i<returned; i++) {
00086                 if (!smb_io_printer_info_1("", buffer, &inf[i], 0)) {
00087                         return False;
00088                 }
00089         }
00090 
00091         *info=inf;
00092         return True;
00093 }

static BOOL decode_printer_info_2 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
PRINTER_INFO_2 **  info 
) [static]

cli_spoolss.c98 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_printer_info_2().

参照元 rpccli_spoolss_enum_printers()rpccli_spoolss_getprinter().

00100 {
00101         uint32 i;
00102         PRINTER_INFO_2  *inf;
00103 
00104         if (returned) {
00105                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_2, returned);
00106                 if (!inf) {
00107                         return False;
00108                 }
00109                 memset(inf, 0, returned*sizeof(PRINTER_INFO_2));
00110         } else {
00111                 inf = NULL;
00112         }
00113 
00114         prs_set_offset(&buffer->prs,0);
00115 
00116         for (i=0; i<returned; i++) {
00117                 /* a little initialization as we go */
00118                 inf[i].secdesc = NULL;
00119                 if (!smb_io_printer_info_2("", buffer, &inf[i], 0)) {
00120                         return False;
00121                 }
00122         }
00123 
00124         *info=inf;
00125         return True;
00126 }

static BOOL decode_printer_info_3 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
PRINTER_INFO_3 **  info 
) [static]

cli_spoolss.c131 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_printer_info_3().

参照元 rpccli_spoolss_enum_printers()rpccli_spoolss_getprinter().

00133 {
00134         uint32 i;
00135         PRINTER_INFO_3  *inf;
00136 
00137         if (returned) {
00138                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_3, returned);
00139                 if (!inf) {
00140                         return False;
00141                 }
00142                 memset(inf, 0, returned*sizeof(PRINTER_INFO_3));
00143         } else {
00144                 inf = NULL;
00145         }
00146 
00147         prs_set_offset(&buffer->prs,0);
00148 
00149         for (i=0; i<returned; i++) {
00150                 inf[i].secdesc = NULL;
00151                 if (!smb_io_printer_info_3("", buffer, &inf[i], 0)) {
00152                         return False;
00153                 }
00154         }
00155 
00156         *info=inf;
00157         return True;
00158 }

static BOOL decode_printer_info_7 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
PRINTER_INFO_7 **  info 
) [static]

cli_spoolss.c163 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_printer_info_7().

参照元 rpccli_spoolss_getprinter().

00165 {
00166         uint32 i;
00167         PRINTER_INFO_7  *inf;
00168 
00169         if (returned) {
00170                 inf=TALLOC_ARRAY(mem_ctx, PRINTER_INFO_7, returned);
00171                 if (!inf) {
00172                         return False;
00173                 }
00174                 memset(inf, 0, returned*sizeof(PRINTER_INFO_7));
00175         } else {
00176                 inf = NULL;
00177         }
00178 
00179         prs_set_offset(&buffer->prs,0);
00180 
00181         for (i=0; i<returned; i++) {
00182                 if (!smb_io_printer_info_7("", buffer, &inf[i], 0)) {
00183                         return False;
00184                 }
00185         }
00186 
00187         *info=inf;
00188         return True;
00189 }

static BOOL decode_port_info_1 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
PORT_INFO_1 **  info 
) [static]

cli_spoolss.c195 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_port_info_1().

参照元 rpccli_spoolss_enum_ports().

00197 {
00198         uint32 i;
00199         PORT_INFO_1 *inf;
00200 
00201         if (returned) {
00202                 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_1, returned);
00203                 if (!inf) {
00204                         return False;
00205                 }
00206                 memset(inf, 0, returned*sizeof(PORT_INFO_1));
00207         } else {
00208                 inf = NULL;
00209         }
00210 
00211         prs_set_offset(&buffer->prs, 0);
00212 
00213         for (i=0; i<returned; i++) {
00214                 if (!smb_io_port_info_1("", buffer, &(inf[i]), 0)) {
00215                         return False;
00216                 }
00217         }
00218 
00219         *info=inf;
00220         return True;
00221 }

static BOOL decode_port_info_2 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
PORT_INFO_2 **  info 
) [static]

cli_spoolss.c226 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_port_info_2().

参照元 rpccli_spoolss_enum_ports().

00228 {
00229         uint32 i;
00230         PORT_INFO_2 *inf;
00231 
00232         if (returned) {
00233                 inf=TALLOC_ARRAY(mem_ctx, PORT_INFO_2, returned);
00234                 if (!inf) {
00235                         return False;
00236                 }
00237                 memset(inf, 0, returned*sizeof(PORT_INFO_2));
00238         } else {
00239                 inf = NULL;
00240         }
00241 
00242         prs_set_offset(&buffer->prs, 0);
00243 
00244         for (i=0; i<returned; i++) {
00245                 if (!smb_io_port_info_2("", buffer, &(inf[i]), 0)) {
00246                         return False;
00247                 }
00248         }
00249 
00250         *info=inf;
00251         return True;
00252 }

static BOOL decode_printer_driver_1 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
DRIVER_INFO_1 **  info 
) [static]

cli_spoolss.c257 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_printer_driver_info_1().

参照元 rpccli_spoolss_enumprinterdrivers()rpccli_spoolss_getprinterdriver().

00259 {
00260         uint32 i;
00261         DRIVER_INFO_1 *inf;
00262 
00263         if (returned) {
00264                 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_1, returned);
00265                 if (!inf) {
00266                         return False;
00267                 }
00268                 memset(inf, 0, returned*sizeof(DRIVER_INFO_1));
00269         } else {
00270                 inf = NULL;
00271         }
00272 
00273         prs_set_offset(&buffer->prs,0);
00274 
00275         for (i=0; i<returned; i++) {
00276                 if (!smb_io_printer_driver_info_1("", buffer, &(inf[i]), 0)) {
00277                         return False;
00278                 }
00279         }
00280 
00281         *info=inf;
00282         return True;
00283 }

static BOOL decode_printer_driver_2 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
DRIVER_INFO_2 **  info 
) [static]

cli_spoolss.c288 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_printer_driver_info_2().

参照元 rpccli_spoolss_enumprinterdrivers()rpccli_spoolss_getprinterdriver().

00290 {
00291         uint32 i;
00292         DRIVER_INFO_2 *inf;
00293 
00294         if (returned) {
00295                 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_2, returned);
00296                 if (!inf) {
00297                         return False;
00298                 }
00299                 memset(inf, 0, returned*sizeof(DRIVER_INFO_2));
00300         } else {
00301                 inf = NULL;
00302         }
00303 
00304         prs_set_offset(&buffer->prs,0);
00305 
00306         for (i=0; i<returned; i++) {
00307                 if (!smb_io_printer_driver_info_2("", buffer, &(inf[i]), 0)) {
00308                         return False;
00309                 }
00310         }
00311 
00312         *info=inf;
00313         return True;
00314 }

static BOOL decode_printer_driver_3 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
DRIVER_INFO_3 **  info 
) [static]

cli_spoolss.c319 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_printer_driver_info_3().

参照元 rpccli_spoolss_enumprinterdrivers()rpccli_spoolss_getprinterdriver().

00321 {
00322         uint32 i;
00323         DRIVER_INFO_3 *inf;
00324 
00325         if (returned) {
00326                 inf=TALLOC_ARRAY(mem_ctx, DRIVER_INFO_3, returned);
00327                 if (!inf) {
00328                         return False;
00329                 }
00330                 memset(inf, 0, returned*sizeof(DRIVER_INFO_3));
00331         } else {
00332                 inf = NULL;
00333         }
00334 
00335         prs_set_offset(&buffer->prs,0);
00336 
00337         for (i=0; i<returned; i++) {
00338                 if (!smb_io_printer_driver_info_3("", buffer, &(inf[i]), 0)) {
00339                         return False;
00340                 }
00341         }
00342 
00343         *info=inf;
00344         return True;
00345 }

static BOOL decode_printerdriverdir_1 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  returned,
DRIVER_DIRECTORY_1 **  info 
) [static]

cli_spoolss.c350 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_driverdir_1().

参照元 rpccli_spoolss_getprinterdriverdir().

00353 {
00354         DRIVER_DIRECTORY_1 *inf;
00355  
00356         inf=TALLOC_P(mem_ctx, DRIVER_DIRECTORY_1);
00357         if (!inf) {
00358                 return False;
00359         }
00360         memset(inf, 0, sizeof(DRIVER_DIRECTORY_1));
00361 
00362         prs_set_offset(&buffer->prs, 0);
00363 
00364         if (!smb_io_driverdir_1("", buffer, inf, 0)) {
00365                 return False;
00366         }
00367  
00368         *info=inf;
00369         return True;
00370 }

static BOOL decode_jobs_1 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  num_jobs,
JOB_INFO_1 **  jobs 
) [static]

cli_spoolss.c375 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_job_info_1().

参照元 rpccli_spoolss_enumjobs()rpccli_spoolss_getjob().

00377 {
00378         uint32 i;
00379 
00380         if (num_jobs) {
00381                 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_1, num_jobs);
00382                 if (*jobs == NULL) {
00383                         return False;
00384                 }
00385         } else {
00386                 *jobs = NULL;
00387         }
00388         prs_set_offset(&buffer->prs,0);
00389 
00390         for (i = 0; i < num_jobs; i++) {
00391                 if (!smb_io_job_info_1("", buffer, &((*jobs)[i]), 0)) {
00392                         return False;
00393                 }
00394         }
00395 
00396         return True;
00397 }

static BOOL decode_jobs_2 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  num_jobs,
JOB_INFO_2 **  jobs 
) [static]

cli_spoolss.c402 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_job_info_2().

参照元 rpccli_spoolss_enumjobs()rpccli_spoolss_getjob().

00404 {
00405         uint32 i;
00406 
00407         if (num_jobs) {
00408                 *jobs = TALLOC_ARRAY(mem_ctx, JOB_INFO_2, num_jobs);
00409                 if (*jobs == NULL) {
00410                         return False;
00411                 }
00412         } else {
00413                 *jobs = NULL;
00414         }
00415         prs_set_offset(&buffer->prs,0);
00416 
00417         for (i = 0; i < num_jobs; i++) {
00418                 if (!smb_io_job_info_2("", buffer, &((*jobs)[i]), 0)) {
00419                         return False;
00420                 }
00421         }
00422 
00423         return True;
00424 }

static BOOL decode_forms_1 ( TALLOC_CTX mem_ctx,
RPC_BUFFER buffer,
uint32  num_forms,
FORM_1 **  forms 
) [static]

cli_spoolss.c429 行で定義されています。

参照先 RPC_BUFFER::prssmb_io_form_1().

参照元 rpccli_spoolss_enumforms().

00431 {
00432         int i;
00433 
00434         if (num_forms) {
00435                 *forms = TALLOC_ARRAY(mem_ctx, FORM_1, num_forms);
00436                 if (*forms == NULL) {
00437                         return False;
00438                 }
00439         } else {
00440                 *forms = NULL;
00441         }
00442 
00443         prs_set_offset(&buffer->prs,0);
00444 
00445         for (i = 0; i < num_forms; i++) {
00446                 if (!smb_io_form_1("", buffer, &((*forms)[i]), 0)) {
00447                         return False;
00448                 }
00449         }
00450 
00451         return True;
00452 }

WERROR rpccli_spoolss_open_printer_ex ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
const char *  printername,
const char *  datatype,
uint32  access_required,
const char *  station,
const char *  username,
POLICY_HND pol 
)

cli_spoolss.c457 行で定義されています。

参照先 cliSPOOL_R_OPEN_PRINTER_EX::handlemake_spoolss_q_open_printer_ex()polspoolss_io_q_open_printer_ex()spoolss_io_r_open_printer_ex()SPOOL_R_OPEN_PRINTER_EX::status.

参照元 cmd_spoolss_addform()cmd_spoolss_deleteform()cmd_spoolss_enum_data()cmd_spoolss_enum_data_ex()cmd_spoolss_enum_forms()cmd_spoolss_enum_jobs()cmd_spoolss_enum_printerkey()cmd_spoolss_getdriver()cmd_spoolss_getform()cmd_spoolss_getprinter()cmd_spoolss_getprinterdata()cmd_spoolss_getprinterdataex()cmd_spoolss_open_printer_ex()cmd_spoolss_printercmp()cmd_spoolss_rffpcnex()cmd_spoolss_setdriver()cmd_spoolss_setform()cmd_spoolss_setprinter()cmd_spoolss_setprinterdata()cmd_spoolss_setprintername()get_remote_printer_publishing_data()net_spoolss_open_printer_ex()spoolss_openprinter().

00460 {
00461         prs_struct qbuf, rbuf;
00462         SPOOL_Q_OPEN_PRINTER_EX in;
00463         SPOOL_R_OPEN_PRINTER_EX out;
00464 
00465         ZERO_STRUCT(in);
00466         ZERO_STRUCT(out);
00467 
00468         make_spoolss_q_open_printer_ex( &in, printername, datatype,
00469                 access_required, station, username );
00470 
00471         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_OPENPRINTEREX,
00472                     in, out, 
00473                     qbuf, rbuf,
00474                     spoolss_io_q_open_printer_ex,
00475                     spoolss_io_r_open_printer_ex, 
00476                     WERR_GENERAL_FAILURE );
00477 
00478         memcpy( pol, &out.handle, sizeof(POLICY_HND) );
00479         
00480         return out.status;
00481 }

WERROR rpccli_spoolss_close_printer ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND pol 
)

cli_spoolss.c486 行で定義されています。

参照先 climake_spoolss_q_closeprinter()polspoolss_io_q_closeprinter()spoolss_io_r_closeprinter()spool_r_closeprinter::status.

参照元 cmd_spoolss_addform()cmd_spoolss_deleteform()cmd_spoolss_enum_data()cmd_spoolss_enum_data_ex()cmd_spoolss_enum_forms()cmd_spoolss_enum_jobs()cmd_spoolss_enum_printerkey()cmd_spoolss_getdriver()cmd_spoolss_getform()cmd_spoolss_getprinter()cmd_spoolss_getprinterdata()cmd_spoolss_getprinterdataex()cmd_spoolss_open_printer_ex()cmd_spoolss_printercmp()cmd_spoolss_rffpcnex()cmd_spoolss_setdriver()cmd_spoolss_setform()cmd_spoolss_setprinter()cmd_spoolss_setprinterdata()cmd_spoolss_setprintername()get_printer_info()get_remote_printer_publishing_data()rpc_printer_migrate_drivers_internals()rpc_printer_migrate_forms_internals()rpc_printer_migrate_printers_internals()rpc_printer_migrate_security_internals()rpc_printer_publish_internals_args()rpc_printer_publish_list_internals()spoolss_closeprinter().

00488 {
00489         prs_struct qbuf, rbuf;
00490         SPOOL_Q_CLOSEPRINTER in;
00491         SPOOL_R_CLOSEPRINTER out;
00492 
00493         ZERO_STRUCT(in);
00494         ZERO_STRUCT(out);
00495 
00496         make_spoolss_q_closeprinter( &in, pol );
00497 
00498         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_CLOSEPRINTER,
00499                     in, out, 
00500                     qbuf, rbuf,
00501                     spoolss_io_q_closeprinter,
00502                     spoolss_io_r_closeprinter, 
00503                     WERR_GENERAL_FAILURE );
00504                     
00505         return out.status;
00506 }

WERROR rpccli_spoolss_enum_printers ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
char *  name,
uint32  flags,
uint32  level,
uint32 *  num_printers,
PRINTER_INFO_CTR ctr 
)

cli_spoolss.c511 行で定義されています。

参照先 spool_r_enumprinters::bufferclidecode_printer_info_0()decode_printer_info_1()decode_printer_info_2()decode_printer_info_3()make_spoolss_q_enumprinters()spool_r_enumprinters::neededprinter_info_ctr_info::printers_0printer_info_ctr_info::printers_1printer_info_ctr_info::printers_2printer_info_ctr_info::printers_3spool_r_enumprinters::returnedrpcbuf_init()spoolss_io_q_enumprinters()spoolss_io_r_enumprinters()spool_r_enumprinters::status.

参照元 cmd_spoolss_enum_printers()net_spoolss_enum_printers()spoolss_enumprinters().

00514 {
00515         prs_struct qbuf, rbuf;
00516         SPOOL_Q_ENUMPRINTERS in;
00517         SPOOL_R_ENUMPRINTERS out;
00518         RPC_BUFFER buffer;
00519         uint32 offered;
00520 
00521         ZERO_STRUCT(in);
00522         ZERO_STRUCT(out);
00523 
00524         offered = 0;
00525         rpcbuf_init(&buffer, offered, mem_ctx);
00526         make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
00527 
00528         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERS,
00529                     in, out, 
00530                     qbuf, rbuf,
00531                     spoolss_io_q_enumprinters,
00532                     spoolss_io_r_enumprinters, 
00533                     WERR_GENERAL_FAILURE );
00534                     
00535         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00536                 offered = out.needed;
00537                 
00538                 ZERO_STRUCT(in);
00539                 ZERO_STRUCT(out);
00540 
00541                 rpcbuf_init(&buffer, offered, mem_ctx);
00542                 make_spoolss_q_enumprinters( &in, flags, name, level, &buffer, offered );
00543 
00544                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERS,
00545                             in, out, 
00546                             qbuf, rbuf,
00547                             spoolss_io_q_enumprinters,
00548                             spoolss_io_r_enumprinters, 
00549                             WERR_GENERAL_FAILURE );
00550         }
00551 
00552         if ( !W_ERROR_IS_OK(out.status) )
00553                 return out.status;
00554 
00555         switch (level) {
00556         case 0:
00557                 if (!decode_printer_info_0(mem_ctx, out.buffer, out.returned, &ctr->printers_0)) {
00558                         return WERR_GENERAL_FAILURE;
00559                 }
00560                 break;
00561         case 1:
00562                 if (!decode_printer_info_1(mem_ctx, out.buffer, out.returned, &ctr->printers_1)) {
00563                         return WERR_GENERAL_FAILURE;
00564                 }
00565                 break;
00566         case 2:
00567                 if (!decode_printer_info_2(mem_ctx, out.buffer, out.returned, &ctr->printers_2)) {
00568                         return WERR_GENERAL_FAILURE;
00569                 }
00570                 break;
00571         case 3:
00572                 if (!decode_printer_info_3(mem_ctx, out.buffer, out.returned, &ctr->printers_3)) {
00573                         return WERR_GENERAL_FAILURE;
00574                 }
00575                 break;
00576         default:
00577                 return WERR_UNKNOWN_LEVEL;
00578         }                       
00579 
00580         *num_printers = out.returned;
00581 
00582         return out.status;
00583 }

WERROR rpccli_spoolss_enum_ports ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
uint32  level,
uint32 *  num_ports,
PORT_INFO_CTR ctr 
)

cli_spoolss.c588 行で定義されています。

参照先 spool_r_enumports::bufferclidecode_port_info_1()decode_port_info_2()cli_state::desthostport_info_ctr_info::info_1port_info_ctr_info::info_2make_spoolss_q_enumports()spool_r_enumports::neededport_info_ctr_info::portspool_r_enumports::returnedrpcbuf_init()serverspoolss_io_q_enumports()spoolss_io_r_enumports()spool_r_enumports::statusstrupper_m().

参照元 cmd_spoolss_enum_ports()spoolss_enumports().

00590 {
00591         prs_struct qbuf, rbuf;
00592         SPOOL_Q_ENUMPORTS in;
00593         SPOOL_R_ENUMPORTS out;
00594         RPC_BUFFER buffer;
00595         fstring server;
00596         uint32 offered;
00597 
00598         ZERO_STRUCT(in);
00599         ZERO_STRUCT(out);
00600 
00601         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
00602         strupper_m(server);
00603 
00604         offered = 0;
00605         rpcbuf_init(&buffer, offered, mem_ctx);
00606         make_spoolss_q_enumports( &in, server, level, &buffer, offered );
00607         
00608         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPORTS,
00609                     in, out, 
00610                     qbuf, rbuf,
00611                     spoolss_io_q_enumports,
00612                     spoolss_io_r_enumports, 
00613                     WERR_GENERAL_FAILURE );
00614                         
00615         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00616                 offered = out.needed;
00617                 
00618                 ZERO_STRUCT(in);
00619                 ZERO_STRUCT(out);
00620                 
00621                 rpcbuf_init(&buffer, offered, mem_ctx);
00622                 make_spoolss_q_enumports( &in, server, level, &buffer, offered );
00623 
00624                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPORTS,
00625                             in, out, 
00626                             qbuf, rbuf,
00627                             spoolss_io_q_enumports,
00628                             spoolss_io_r_enumports, 
00629                             WERR_GENERAL_FAILURE );
00630         }
00631         
00632         if ( !W_ERROR_IS_OK(out.status) )
00633                 return out.status;
00634         
00635         switch (level) {
00636         case 1:
00637                 if (!decode_port_info_1(mem_ctx, out.buffer, out.returned, &ctr->port.info_1)) {
00638                         return WERR_GENERAL_FAILURE;
00639                 }
00640                 break;
00641         case 2:
00642                 if (!decode_port_info_2(mem_ctx, out.buffer, out.returned, &ctr->port.info_2)) {
00643                         return WERR_GENERAL_FAILURE;
00644                 }
00645                 break;
00646         default:
00647                 return WERR_UNKNOWN_LEVEL;
00648         }
00649 
00650         *num_ports = out.returned;
00651 
00652         return out.status;
00653 }

WERROR rpccli_spoolss_getprinter ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND pol,
uint32  level,
PRINTER_INFO_CTR ctr 
)

cli_spoolss.c658 行で定義されています。

参照先 spool_r_getprinter::bufferclidecode_printer_info_0()decode_printer_info_1()decode_printer_info_2()decode_printer_info_3()decode_printer_info_7()make_spoolss_q_getprinter()spool_r_getprinter::neededpolprinter_info_ctr_info::printers_0printer_info_ctr_info::printers_1printer_info_ctr_info::printers_2printer_info_ctr_info::printers_3printer_info_ctr_info::printers_7rpcbuf_init()spoolss_io_q_getprinter()spoolss_io_r_getprinter()spool_r_getprinter::status.

参照元 cmd_spoolss_getprinter()cmd_spoolss_setdriver()cmd_spoolss_setprinter()cmd_spoolss_setprinterdata()cmd_spoolss_setprintername()compare_printer()compare_printer_secdesc()net_spoolss_getprinter()spoolss_hnd_getprinter().

00661 {
00662         prs_struct qbuf, rbuf;
00663         SPOOL_Q_GETPRINTER in;
00664         SPOOL_R_GETPRINTER out;
00665         RPC_BUFFER buffer;
00666         uint32 offered;
00667 
00668         ZERO_STRUCT(in);
00669         ZERO_STRUCT(out);
00670 
00671         /* Initialise input parameters */
00672 
00673         offered = 0;
00674         rpcbuf_init(&buffer, offered, mem_ctx);
00675         make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
00676         
00677         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTER,
00678                     in, out, 
00679                     qbuf, rbuf,
00680                     spoolss_io_q_getprinter,
00681                     spoolss_io_r_getprinter, 
00682                     WERR_GENERAL_FAILURE );
00683 
00684         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00685                 offered = out.needed;
00686                 
00687                 ZERO_STRUCT(in);
00688                 ZERO_STRUCT(out);
00689                 
00690                 rpcbuf_init(&buffer, offered, mem_ctx);
00691                 make_spoolss_q_getprinter( mem_ctx, &in, pol, level, &buffer, offered );
00692 
00693                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTER,
00694                             in, out, 
00695                             qbuf, rbuf,
00696                             spoolss_io_q_getprinter,
00697                             spoolss_io_r_getprinter, 
00698                             WERR_GENERAL_FAILURE );
00699         }
00700         
00701         if ( !W_ERROR_IS_OK(out.status) )
00702                 return out.status;
00703                 
00704         switch (level) {
00705         case 0:
00706                 if (!decode_printer_info_0(mem_ctx, out.buffer, 1, &ctr->printers_0)) {
00707                         return WERR_GENERAL_FAILURE;
00708                 }
00709                 break;
00710         case 1:
00711                 if (!decode_printer_info_1(mem_ctx, out.buffer, 1, &ctr->printers_1)) {
00712                         return WERR_GENERAL_FAILURE;
00713                 }
00714                 break;
00715         case 2:
00716                 if (!decode_printer_info_2(mem_ctx, out.buffer, 1, &ctr->printers_2)) {
00717                         return WERR_GENERAL_FAILURE;
00718                 }
00719                 break;
00720         case 3:
00721                 if (!decode_printer_info_3(mem_ctx, out.buffer, 1, &ctr->printers_3)) {
00722                         return WERR_GENERAL_FAILURE;
00723                 }
00724                 break;
00725         case 7:
00726                 if (!decode_printer_info_7(mem_ctx, out.buffer, 1, &ctr->printers_7)) {
00727                         return WERR_GENERAL_FAILURE;
00728                 }
00729                 break;
00730         default:
00731                 return WERR_UNKNOWN_LEVEL;
00732         }
00733 
00734         return out.status;
00735 }

WERROR rpccli_spoolss_setprinter ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND pol,
uint32  level,
PRINTER_INFO_CTR ctr,
uint32  command 
)

cli_spoolss.c740 行で定義されています。

参照先 climake_spoolss_q_setprinter()polspoolss_io_q_setprinter()spoolss_io_r_setprinter()spool_r_setprinter::status.

参照元 cmd_spoolss_setdriver()cmd_spoolss_setprinter()cmd_spoolss_setprintername()net_spoolss_setprinter()rpc_printer_publish_internals_args()spoolss_hnd_setprinter().

00743 {
00744         prs_struct qbuf, rbuf;
00745         SPOOL_Q_SETPRINTER in;
00746         SPOOL_R_SETPRINTER out;
00747 
00748         ZERO_STRUCT(in);
00749         ZERO_STRUCT(out);
00750 
00751         make_spoolss_q_setprinter( mem_ctx, &in, pol, level, ctr, command );
00752 
00753         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTER,
00754                     in, out, 
00755                     qbuf, rbuf,
00756                     spoolss_io_q_setprinter,
00757                     spoolss_io_r_setprinter, 
00758                     WERR_GENERAL_FAILURE );
00759 
00760         return out.status;
00761 }

WERROR rpccli_spoolss_getprinterdriver ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND pol,
uint32  level,
const char *  env,
int  version,
PRINTER_DRIVER_CTR ctr 
)

cli_spoolss.c766 行で定義されています。

参照先 spool_r_getprinterdriver2::bufferclidecode_printer_driver_1()decode_printer_driver_2()decode_printer_driver_3()cli_state::desthostdriver_info_info::info1driver_info_info::info2driver_info_info::info3make_spoolss_q_getprinterdriver2()spool_r_getprinterdriver2::neededpolrpcbuf_init()serverspoolss_io_q_getprinterdriver2()spoolss_io_r_getprinterdriver2()spool_r_getprinterdriver2::statusstrupper_m().

参照元 cmd_spoolss_getdriver()net_spoolss_getprinterdriver()spoolss_hnd_getprinterdriver().

00770 {
00771         prs_struct qbuf, rbuf;
00772         SPOOL_Q_GETPRINTERDRIVER2 in;
00773         SPOOL_R_GETPRINTERDRIVER2 out;
00774         RPC_BUFFER buffer;
00775         fstring server;
00776         uint32 offered;
00777 
00778         ZERO_STRUCT(in);
00779         ZERO_STRUCT(out);
00780 
00781         fstrcpy(server, cli->cli->desthost);
00782         strupper_m(server);
00783 
00784         offered = 0;
00785         rpcbuf_init(&buffer, offered, mem_ctx);
00786         make_spoolss_q_getprinterdriver2( &in, pol, env, level, 
00787                 version, 2, &buffer, offered);
00788 
00789         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVER2,
00790                     in, out, 
00791                     qbuf, rbuf,
00792                     spoolss_io_q_getprinterdriver2,
00793                     spoolss_io_r_getprinterdriver2, 
00794                     WERR_GENERAL_FAILURE );
00795                     
00796         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00797                 offered = out.needed;
00798                 
00799                 ZERO_STRUCT(in);
00800                 ZERO_STRUCT(out);
00801                 
00802                 rpcbuf_init(&buffer, offered, mem_ctx);
00803                 make_spoolss_q_getprinterdriver2( &in, pol, env, level, 
00804                         version, 2, &buffer, offered);
00805 
00806                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVER2,
00807                             in, out, 
00808                             qbuf, rbuf,
00809                             spoolss_io_q_getprinterdriver2,
00810                             spoolss_io_r_getprinterdriver2, 
00811                             WERR_GENERAL_FAILURE );
00812         }
00813                 
00814         if ( !W_ERROR_IS_OK(out.status) )
00815                 return out.status;
00816 
00817         switch (level) {
00818         case 1:
00819                 if (!decode_printer_driver_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
00820                         return WERR_GENERAL_FAILURE;
00821                 }
00822                 break;
00823         case 2:
00824                 if (!decode_printer_driver_2(mem_ctx, out.buffer, 1, &ctr->info2)) {
00825                         return WERR_GENERAL_FAILURE;
00826                 }
00827                 break;
00828         case 3:
00829                 if (!decode_printer_driver_3(mem_ctx, out.buffer, 1, &ctr->info3)) {
00830                         return WERR_GENERAL_FAILURE;
00831                 }
00832                 break;
00833         default:
00834                 return WERR_UNKNOWN_LEVEL;
00835         }
00836 
00837         return out.status;      
00838 }

WERROR rpccli_spoolss_enumprinterdrivers ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
uint32  level,
const char *  env,
uint32 *  num_drivers,
PRINTER_DRIVER_CTR ctr 
)

cli_spoolss.c843 行で定義されています。

参照先 spool_r_enumprinterdrivers::bufferclidecode_printer_driver_1()decode_printer_driver_2()decode_printer_driver_3()cli_state::desthostdriver_info_info::info1driver_info_info::info2driver_info_info::info3make_spoolss_q_enumprinterdrivers()spool_r_enumprinterdrivers::neededspool_r_enumprinterdrivers::returnedrpcbuf_init()serverspoolss_io_q_enumprinterdrivers()spoolss_io_r_enumprinterdrivers()spool_r_enumprinterdrivers::statusstrupper_m().

参照元 cmd_spoolss_enum_drivers()net_spoolss_enumprinterdrivers()spoolss_enumprinterdrivers().

00848 {
00849         prs_struct qbuf, rbuf;
00850         SPOOL_Q_ENUMPRINTERDRIVERS in;
00851         SPOOL_R_ENUMPRINTERDRIVERS out;
00852         RPC_BUFFER buffer;
00853         fstring server;
00854         uint32 offered;
00855 
00856         ZERO_STRUCT(in);
00857         ZERO_STRUCT(out);
00858 
00859         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
00860         strupper_m(server);
00861 
00862         offered = 0;
00863         rpcbuf_init(&buffer, offered, mem_ctx);
00864         make_spoolss_q_enumprinterdrivers( &in, server, env, level, 
00865                 &buffer, offered);
00866         
00867         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDRIVERS,
00868                     in, out, 
00869                     qbuf, rbuf,
00870                     spoolss_io_q_enumprinterdrivers,
00871                     spoolss_io_r_enumprinterdrivers, 
00872                     WERR_GENERAL_FAILURE );
00873 
00874         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00875                 offered = out.needed;
00876                 
00877                 ZERO_STRUCT(in);
00878                 ZERO_STRUCT(out);
00879                 
00880                 rpcbuf_init(&buffer, offered, mem_ctx);
00881                 make_spoolss_q_enumprinterdrivers( &in, server, env, level, 
00882                         &buffer, offered);
00883         
00884                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDRIVERS,
00885                             in, out, 
00886                             qbuf, rbuf,
00887                             spoolss_io_q_enumprinterdrivers,
00888                             spoolss_io_r_enumprinterdrivers, 
00889                             WERR_GENERAL_FAILURE );
00890         }
00891         
00892         *num_drivers = out.returned;
00893 
00894         if ( !W_ERROR_IS_OK(out.status) )
00895                 return out.status;
00896                 
00897         if ( out.returned ) {
00898 
00899                 switch (level) {
00900                 case 1:
00901                         if (!decode_printer_driver_1(mem_ctx, out.buffer, out.returned, &ctr->info1)) {
00902                                 return WERR_GENERAL_FAILURE;
00903                         }
00904                         break;
00905                 case 2:
00906                         if (!decode_printer_driver_2(mem_ctx, out.buffer, out.returned, &ctr->info2)) {
00907                                 return WERR_GENERAL_FAILURE;
00908                         }
00909                         break;
00910                 case 3:
00911                         if (!decode_printer_driver_3(mem_ctx, out.buffer, out.returned, &ctr->info3)) {
00912                                 return WERR_GENERAL_FAILURE;
00913                         }
00914                         break;
00915                 default:
00916                         return WERR_UNKNOWN_LEVEL;
00917                 }
00918         }
00919 
00920         return out.status;
00921 }

WERROR rpccli_spoolss_getprinterdriverdir ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
uint32  level,
char *  env,
DRIVER_DIRECTORY_CTR ctr 
)

cli_spoolss.c927 行で定義されています。

参照先 spool_r_getprinterdriverdirectory::bufferclidecode_printerdriverdir_1()cli_state::desthostdriver_info_ctr_info::info1make_spoolss_q_getprinterdriverdir()spool_r_getprinterdriverdirectory::neededrpcbuf_init()serverspoolss_io_q_getprinterdriverdir()spoolss_io_r_getprinterdriverdir()spool_r_getprinterdriverdirectory::statusstrupper_m().

参照元 cmd_spoolss_getdriverdir()spoolss_getprinterdriverdir().

00931 {
00932         prs_struct qbuf, rbuf;
00933         SPOOL_Q_GETPRINTERDRIVERDIR in;
00934         SPOOL_R_GETPRINTERDRIVERDIR out;
00935         RPC_BUFFER buffer;
00936         fstring server;
00937         uint32 offered;
00938 
00939         ZERO_STRUCT(in);
00940         ZERO_STRUCT(out);
00941 
00942         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
00943         strupper_m(server);
00944 
00945         offered = 0;
00946         rpcbuf_init(&buffer, offered, mem_ctx);
00947         make_spoolss_q_getprinterdriverdir( &in, server, env, level, 
00948                 &buffer, offered );
00949 
00950         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
00951                     in, out, 
00952                     qbuf, rbuf,
00953                     spoolss_io_q_getprinterdriverdir,
00954                     spoolss_io_r_getprinterdriverdir, 
00955                     WERR_GENERAL_FAILURE );
00956                     
00957         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
00958                 offered = out.needed;
00959                 
00960                 ZERO_STRUCT(in);
00961                 ZERO_STRUCT(out);
00962                 
00963                 rpcbuf_init(&buffer, offered, mem_ctx);
00964                 make_spoolss_q_getprinterdriverdir( &in, server, env, level, 
00965                         &buffer, offered );
00966 
00967                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDRIVERDIRECTORY,
00968                             in, out, 
00969                             qbuf, rbuf,
00970                             spoolss_io_q_getprinterdriverdir,
00971                             spoolss_io_r_getprinterdriverdir, 
00972                             WERR_GENERAL_FAILURE );
00973         }
00974         
00975         if (!W_ERROR_IS_OK(out.status))
00976                 return out.status;
00977                 
00978         if (!decode_printerdriverdir_1(mem_ctx, out.buffer, 1, &ctr->info1)) {
00979                 return WERR_GENERAL_FAILURE;
00980         }
00981 
00982         return out.status;
00983 }

WERROR rpccli_spoolss_addprinterdriver ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
uint32  level,
PRINTER_DRIVER_CTR ctr 
)

cli_spoolss.c988 行で定義されています。

参照先 clicli_state::desthostmake_spoolss_q_addprinterdriver()serverspoolss_io_q_addprinterdriver()spoolss_io_r_addprinterdriver()spool_r_addprinterdriver::statusstrupper_m().

参照元 cmd_spoolss_addprinterdriver()net_spoolss_addprinterdriver()spoolss_addprinterdriver().

00991 {
00992         prs_struct qbuf, rbuf;
00993         SPOOL_Q_ADDPRINTERDRIVER in;
00994         SPOOL_R_ADDPRINTERDRIVER out;
00995         fstring server;
00996 
00997         ZERO_STRUCT(in);
00998         ZERO_STRUCT(out);
00999         
01000         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
01001         strupper_m(server);
01002 
01003         make_spoolss_q_addprinterdriver( mem_ctx, &in, server, level, ctr );
01004 
01005         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDPRINTERDRIVER,
01006                     in, out, 
01007                     qbuf, rbuf,
01008                     spoolss_io_q_addprinterdriver,
01009                     spoolss_io_r_addprinterdriver, 
01010                     WERR_GENERAL_FAILURE );
01011 
01012         return out.status;                  
01013 }

WERROR rpccli_spoolss_addprinterex ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
uint32  level,
PRINTER_INFO_CTR ctr 
)

cli_spoolss.c1018 行で定義されています。

参照先 clicli_state::desthostglobal_mynamemake_spoolss_q_addprinterex()serverspoolss_io_q_addprinterex()spoolss_io_r_addprinterex()SPOOL_R_ADDPRINTEREX::statusstrupper_m()cli_state::user_name.

参照元 cmd_spoolss_addprinterex()rpc_printer_migrate_printers_internals()spoolss_addprinterex().

01020 {
01021         prs_struct qbuf, rbuf;
01022         SPOOL_Q_ADDPRINTEREX in;
01023         SPOOL_R_ADDPRINTEREX out;
01024         fstring server, client, user;
01025 
01026         ZERO_STRUCT(in);
01027         ZERO_STRUCT(out);
01028         
01029         slprintf(client, sizeof(fstring)-1, "\\\\%s", global_myname());
01030         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
01031         
01032         strupper_m(client);
01033         strupper_m(server);
01034 
01035         fstrcpy  (user, cli->user_name);
01036 
01037         make_spoolss_q_addprinterex( mem_ctx, &in, server, client, 
01038                 user, level, ctr);
01039 
01040         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDPRINTEREX,
01041                     in, out, 
01042                     qbuf, rbuf,
01043                     spoolss_io_q_addprinterex,
01044                     spoolss_io_r_addprinterex, 
01045                     WERR_GENERAL_FAILURE );
01046 
01047         return out.status;      
01048 }

WERROR rpccli_spoolss_deleteprinterdriverex ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
const char *  arch,
const char *  driver,
int  version 
)

cli_spoolss.c1053 行で定義されています。

参照先 clicli_state::desthostmake_spoolss_q_deleteprinterdriverex()serverspoolss_io_q_deleteprinterdriverex()spoolss_io_r_deleteprinterdriverex()spool_r_deleteprinterdriverex::statusstrupper_m().

参照元 cmd_spoolss_deletedriverex().

01056 {
01057         prs_struct qbuf, rbuf;
01058         SPOOL_Q_DELETEPRINTERDRIVEREX in;
01059         SPOOL_R_DELETEPRINTERDRIVEREX out;
01060         fstring server;
01061 
01062         ZERO_STRUCT(in);
01063         ZERO_STRUCT(out);
01064 
01065         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
01066         strupper_m(server);
01067 
01068         make_spoolss_q_deleteprinterdriverex( mem_ctx, &in, server, arch, driver, version );
01069 
01070         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDRIVEREX,
01071                     in, out, 
01072                     qbuf, rbuf,
01073                     spoolss_io_q_deleteprinterdriverex,
01074                     spoolss_io_r_deleteprinterdriverex, 
01075                     WERR_GENERAL_FAILURE );
01076                     
01077         return out.status;      
01078 }

WERROR rpccli_spoolss_deleteprinterdriver ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
const char *  arch,
const char *  driver 
)

cli_spoolss.c1083 行で定義されています。

参照先 clicli_state::desthostmake_spoolss_q_deleteprinterdriver()serverspoolss_io_q_deleteprinterdriver()spoolss_io_r_deleteprinterdriver()spool_r_deleteprinterdriver::statusstrupper_m().

参照元 cmd_spoolss_deletedriver().

01086 {
01087         prs_struct qbuf, rbuf;
01088         SPOOL_Q_DELETEPRINTERDRIVER in;
01089         SPOOL_R_DELETEPRINTERDRIVER out;
01090         fstring server;
01091 
01092         ZERO_STRUCT(in);
01093         ZERO_STRUCT(out);
01094 
01095         slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
01096         strupper_m(server);
01097 
01098         make_spoolss_q_deleteprinterdriver( mem_ctx, &in, server, arch, driver );
01099 
01100         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDRIVER,
01101                     in, out, 
01102                     qbuf, rbuf,
01103                     spoolss_io_q_deleteprinterdriver,
01104                     spoolss_io_r_deleteprinterdriver, 
01105                     WERR_GENERAL_FAILURE );
01106                     
01107         return out.status;      
01108 }

WERROR rpccli_spoolss_getprintprocessordirectory ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
char *  name,
char *  environment,
fstring  procdir 
)

cli_spoolss.c1113 行で定義されています。

参照先 clilevelmake_spoolss_q_getprintprocessordirectory()spool_r_getprintprocessordirectory::neededrpcbuf_init()spoolss_io_q_getprintprocessordirectory()spoolss_io_r_getprintprocessordirectory()spool_r_getprintprocessordirectory::status.

参照元 cmd_spoolss_getprintprocdir().

01117 {
01118         prs_struct qbuf, rbuf;
01119         SPOOL_Q_GETPRINTPROCESSORDIRECTORY in;
01120         SPOOL_R_GETPRINTPROCESSORDIRECTORY out;
01121         int level = 1;
01122         RPC_BUFFER buffer;
01123         uint32 offered;
01124 
01125         ZERO_STRUCT(in);
01126         ZERO_STRUCT(out);
01127 
01128         offered = 0;
01129         rpcbuf_init(&buffer, offered, mem_ctx);
01130         make_spoolss_q_getprintprocessordirectory( &in, name, 
01131                 environment, level, &buffer, offered );
01132 
01133         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
01134                     in, out, 
01135                     qbuf, rbuf,
01136                     spoolss_io_q_getprintprocessordirectory,
01137                     spoolss_io_r_getprintprocessordirectory, 
01138                     WERR_GENERAL_FAILURE );
01139                     
01140         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
01141                 offered = out.needed;
01142                 
01143                 ZERO_STRUCT(in);
01144                 ZERO_STRUCT(out);
01145                 
01146                 rpcbuf_init(&buffer, offered, mem_ctx);
01147                 make_spoolss_q_getprintprocessordirectory( &in, name, 
01148                         environment, level, &buffer, offered );
01149 
01150                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTPROCESSORDIRECTORY,
01151                             in, out, 
01152                             qbuf, rbuf,
01153                             spoolss_io_q_getprintprocessordirectory,
01154                             spoolss_io_r_getprintprocessordirectory, 
01155                             WERR_GENERAL_FAILURE );
01156         }
01157         
01158         if ( !W_ERROR_IS_OK(out.status) )
01159                 return out.status;
01160         
01161         fstrcpy(procdir, "Not implemented!");
01162         
01163         return out.status;
01164 }

WERROR rpccli_spoolss_addform ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND handle,
uint32  level,
FORM form 
)

cli_spoolss.c1169 行で定義されています。

参照先 clihandlemake_spoolss_q_addform()spoolss_io_q_addform()spoolss_io_r_addform()spool_r_addform::status.

参照元 cmd_spoolss_addform()rpc_printer_migrate_forms_internals()spoolss_hnd_addform().

01171 {
01172         prs_struct qbuf, rbuf;
01173         SPOOL_Q_ADDFORM in;
01174         SPOOL_R_ADDFORM out;
01175 
01176         ZERO_STRUCT(in);
01177         ZERO_STRUCT(out);
01178 
01179         make_spoolss_q_addform( &in, handle, level, form );
01180         
01181         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ADDFORM,
01182                     in, out, 
01183                     qbuf, rbuf,
01184                     spoolss_io_q_addform,
01185                     spoolss_io_r_addform, 
01186                     WERR_GENERAL_FAILURE );
01187 
01188         return out.status;
01189 }

WERROR rpccli_spoolss_setform ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND handle,
uint32  level,
const char *  form_name,
FORM form 
)

cli_spoolss.c1194 行で定義されています。

参照先 clihandlemake_spoolss_q_setform()spoolss_io_q_setform()spoolss_io_r_setform()spool_r_setform::status.

参照元 cmd_spoolss_setform()spoolss_hnd_setform().

01197 {
01198         prs_struct qbuf, rbuf;
01199         SPOOL_Q_SETFORM in;
01200         SPOOL_R_SETFORM out;
01201 
01202         ZERO_STRUCT(in);
01203         ZERO_STRUCT(out);
01204 
01205         make_spoolss_q_setform( &in, handle, level, form_name, form );
01206         
01207         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETFORM,
01208                     in, out, 
01209                     qbuf, rbuf,
01210                     spoolss_io_q_setform,
01211                     spoolss_io_r_setform, 
01212                     WERR_GENERAL_FAILURE );
01213 
01214         return out.status;
01215 }

WERROR rpccli_spoolss_getform ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND handle,
const char *  formname,
uint32  level,
FORM_1 form 
)

cli_spoolss.c1220 行で定義されています。

参照先 spool_r_getform::bufferclihandlemake_spoolss_q_getform()spool_r_getform::neededrpcbuf_init()smb_io_form_1()spoolss_io_q_getform()spoolss_io_r_getform()spool_r_getform::status.

参照元 cmd_spoolss_getform()spoolss_hnd_getform().

01223 {
01224         prs_struct qbuf, rbuf;
01225         SPOOL_Q_GETFORM in;
01226         SPOOL_R_GETFORM out;
01227         RPC_BUFFER buffer;
01228         uint32 offered;
01229 
01230         ZERO_STRUCT(in);
01231         ZERO_STRUCT(out);
01232 
01233         offered = 0;
01234         rpcbuf_init(&buffer, offered, mem_ctx);
01235         make_spoolss_q_getform( &in, handle, formname, level, &buffer, offered );
01236         
01237         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETFORM,
01238                     in, out, 
01239                     qbuf, rbuf,
01240                     spoolss_io_q_getform,
01241                     spoolss_io_r_getform, 
01242                     WERR_GENERAL_FAILURE );
01243                     
01244         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
01245                 offered = out.needed;
01246                 
01247                 ZERO_STRUCT(in);
01248                 ZERO_STRUCT(out);
01249                 
01250                 rpcbuf_init(&buffer, offered, mem_ctx);
01251                 make_spoolss_q_getform( &in, handle, formname, level, &buffer, offered );
01252         
01253                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETFORM,
01254                             in, out, 
01255                             qbuf, rbuf,
01256                             spoolss_io_q_getform,
01257                             spoolss_io_r_getform, 
01258                             WERR_GENERAL_FAILURE );
01259         }
01260         
01261         if (!W_ERROR_IS_OK(out.status))
01262                 return out.status;
01263 
01264         if (!smb_io_form_1("", out.buffer, form, 0)) {
01265                 return WERR_GENERAL_FAILURE;
01266         }
01267 
01268         return out.status;
01269 }

WERROR rpccli_spoolss_deleteform ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND handle,
const char *  form_name 
)

cli_spoolss.c1274 行で定義されています。

参照先 clihandlemake_spoolss_q_deleteform()spoolss_io_q_deleteform()spoolss_io_r_deleteform()spool_r_deleteform::status.

参照元 cmd_spoolss_deleteform()spoolss_hnd_deleteform().

01276 {
01277         prs_struct qbuf, rbuf;
01278         SPOOL_Q_DELETEFORM in;
01279         SPOOL_R_DELETEFORM out;
01280 
01281         ZERO_STRUCT(in);
01282         ZERO_STRUCT(out);
01283 
01284         make_spoolss_q_deleteform( &in, handle, form_name );
01285         
01286         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEFORM,
01287                     in, out, 
01288                     qbuf, rbuf,
01289                     spoolss_io_q_deleteform,
01290                     spoolss_io_r_deleteform, 
01291                     WERR_GENERAL_FAILURE );
01292                     
01293         return out.status;
01294 }

WERROR rpccli_spoolss_enumforms ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND handle,
int  level,
uint32 *  num_forms,
FORM_1 **  forms 
)

cli_spoolss.c1299 行で定義されています。

参照先 spool_r_enumforms::bufferclidecode_forms_1()handlemake_spoolss_q_enumforms()spool_r_enumforms::neededspool_r_enumforms::numofformsrpcbuf_init()spoolss_io_q_enumforms()spoolss_io_r_enumforms()spool_r_enumforms::status.

参照元 cmd_spoolss_enum_forms()net_spoolss_enumforms()spoolss_hnd_enumforms().

01302 {
01303         prs_struct qbuf, rbuf;
01304         SPOOL_Q_ENUMFORMS in;
01305         SPOOL_R_ENUMFORMS out;
01306         RPC_BUFFER buffer;
01307         uint32 offered;
01308 
01309         ZERO_STRUCT(in);
01310         ZERO_STRUCT(out);
01311 
01312         offered = 0;
01313         rpcbuf_init(&buffer, offered, mem_ctx);
01314         make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
01315 
01316         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMFORMS,
01317                     in, out, 
01318                     qbuf, rbuf,
01319                     spoolss_io_q_enumforms,
01320                     spoolss_io_r_enumforms, 
01321                     WERR_GENERAL_FAILURE );
01322 
01323         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
01324                 offered = out.needed;
01325                 
01326                 ZERO_STRUCT(in);
01327                 ZERO_STRUCT(out);
01328 
01329                 rpcbuf_init(&buffer, offered, mem_ctx);
01330                 make_spoolss_q_enumforms( &in, handle, level, &buffer, offered );
01331 
01332                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMFORMS,
01333                             in, out, 
01334                             qbuf, rbuf,
01335                             spoolss_io_q_enumforms,
01336                             spoolss_io_r_enumforms, 
01337                             WERR_GENERAL_FAILURE );
01338         }
01339 
01340         if (!W_ERROR_IS_OK(out.status))
01341                 return out.status;
01342 
01343         *num_forms = out.numofforms;
01344         
01345         if (!decode_forms_1(mem_ctx, out.buffer, *num_forms, forms)) {
01346                 return WERR_GENERAL_FAILURE;
01347         }
01348 
01349         return out.status;
01350 }

WERROR rpccli_spoolss_enumjobs ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
uint32  level,
uint32  firstjob,
uint32  num_jobs,
uint32 *  returned,
JOB_INFO_CTR ctr 
)

cli_spoolss.c1355 行で定義されています。

参照先 spool_r_enumjobs::bufferclidecode_jobs_1()decode_jobs_2()job_info_ctr_info::jobjob_info_ctr_info::job_info_1job_info_ctr_info::job_info_2make_spoolss_q_enumjobs()spool_r_enumjobs::neededspool_r_enumjobs::returnedrpcbuf_init()spoolss_io_q_enumjobs()spoolss_io_r_enumjobs()spool_r_enumjobs::status.

参照元 cmd_spoolss_enum_jobs()spoolss_hnd_enumjobs().

01358 {
01359         prs_struct qbuf, rbuf;
01360         SPOOL_Q_ENUMJOBS in;
01361         SPOOL_R_ENUMJOBS out;
01362         RPC_BUFFER buffer;
01363         uint32 offered;
01364 
01365         ZERO_STRUCT(in);
01366         ZERO_STRUCT(out);
01367 
01368         offered = 0;
01369         rpcbuf_init(&buffer, offered, mem_ctx);
01370         make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level, 
01371                 &buffer, offered );
01372 
01373         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMJOBS,
01374                     in, out, 
01375                     qbuf, rbuf,
01376                     spoolss_io_q_enumjobs,
01377                     spoolss_io_r_enumjobs, 
01378                     WERR_GENERAL_FAILURE );
01379 
01380         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
01381                 offered = out.needed;
01382                 
01383                 ZERO_STRUCT(in);
01384                 ZERO_STRUCT(out);
01385 
01386                 rpcbuf_init(&buffer, offered, mem_ctx);
01387                 make_spoolss_q_enumjobs( &in, hnd, firstjob, num_jobs, level, 
01388                         &buffer, offered );
01389 
01390                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMJOBS,
01391                             in, out, 
01392                             qbuf, rbuf,
01393                             spoolss_io_q_enumjobs,
01394                             spoolss_io_r_enumjobs, 
01395                             WERR_GENERAL_FAILURE );
01396         }
01397 
01398         if (!W_ERROR_IS_OK(out.status))
01399                 return out.status;
01400                 
01401         switch(level) {
01402         case 1:
01403                 if (!decode_jobs_1(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_1)) {
01404                         return WERR_GENERAL_FAILURE;
01405                 }
01406                 break;
01407         case 2:
01408                 if (!decode_jobs_2(mem_ctx, out.buffer, out.returned, &ctr->job.job_info_2)) {
01409                         return WERR_GENERAL_FAILURE;
01410                 }
01411                 break;
01412         default:
01413                 DEBUG(3, ("unsupported info level %d", level));
01414                 return WERR_UNKNOWN_LEVEL;
01415         }
01416         
01417         *returned = out.returned;
01418 
01419         return out.status;
01420 }

WERROR rpccli_spoolss_setjob ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
uint32  jobid,
uint32  level,
uint32  command 
)

cli_spoolss.c1425 行で定義されています。

参照先 climake_spoolss_q_setjob()spoolss_io_q_setjob()spoolss_io_r_setjob()spool_r_setjob::status.

参照元 spoolss_hnd_setjob().

01428 {
01429         prs_struct qbuf, rbuf;
01430         SPOOL_Q_SETJOB in;
01431         SPOOL_R_SETJOB out;
01432 
01433         ZERO_STRUCT(in);
01434         ZERO_STRUCT(out);
01435 
01436         make_spoolss_q_setjob( &in, hnd, jobid, level, command );
01437 
01438         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETJOB,
01439                     in, out, 
01440                     qbuf, rbuf,
01441                     spoolss_io_q_setjob,
01442                     spoolss_io_r_setjob, 
01443                     WERR_GENERAL_FAILURE );
01444                     
01445         return out.status;
01446 }

WERROR rpccli_spoolss_getjob ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
uint32  jobid,
uint32  level,
JOB_INFO_CTR ctr 
)

cli_spoolss.c1451 行で定義されています。

参照先 spool_r_getjob::bufferclidecode_jobs_1()decode_jobs_2()job_info_ctr_info::jobjob_info_ctr_info::job_info_1job_info_ctr_info::job_info_2make_spoolss_q_getjob()spool_r_getjob::neededrpcbuf_init()spoolss_io_q_getjob()spoolss_io_r_getjob()spool_r_getjob::status.

参照元 spoolss_hnd_getjob().

01454 {
01455         prs_struct qbuf, rbuf;
01456         SPOOL_Q_GETJOB in;
01457         SPOOL_R_GETJOB out;
01458         RPC_BUFFER buffer;
01459         uint32 offered;
01460 
01461         ZERO_STRUCT(in);
01462         ZERO_STRUCT(out);
01463 
01464         offered = 0;
01465         rpcbuf_init(&buffer, offered, mem_ctx);
01466         make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
01467 
01468         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETJOB,
01469                     in, out, 
01470                     qbuf, rbuf,
01471                     spoolss_io_q_getjob,
01472                     spoolss_io_r_getjob, 
01473                     WERR_GENERAL_FAILURE );
01474 
01475         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
01476                 offered = out.needed;
01477                 
01478                 ZERO_STRUCT(in);
01479                 ZERO_STRUCT(out);
01480                 
01481                 rpcbuf_init(&buffer, offered, mem_ctx);
01482                 make_spoolss_q_getjob( &in, hnd, jobid, level, &buffer, offered );
01483 
01484                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETJOB,
01485                             in, out, 
01486                             qbuf, rbuf,
01487                             spoolss_io_q_getjob,
01488                             spoolss_io_r_getjob, 
01489                             WERR_GENERAL_FAILURE );
01490         }
01491 
01492         if (!W_ERROR_IS_OK(out.status))
01493                 return out.status;
01494 
01495         switch(level) {
01496         case 1:
01497                 if (!decode_jobs_1(mem_ctx, out.buffer, 1, &ctr->job.job_info_1)) {
01498                         return WERR_GENERAL_FAILURE;
01499                 }
01500                 break;
01501         case 2:
01502                 if (!decode_jobs_2(mem_ctx, out.buffer, 1, &ctr->job.job_info_2)) {
01503                         return WERR_GENERAL_FAILURE;
01504                 }
01505                 break;
01506         default:
01507                 return WERR_UNKNOWN_LEVEL;
01508         }
01509 
01510         return out.status;
01511 }

WERROR rpccli_spoolss_startpageprinter ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd 
)

cli_spoolss.c1516 行で定義されています。

参照先 climake_spoolss_q_startpageprinter()spoolss_io_q_startpageprinter()spoolss_io_r_startpageprinter()spool_r_startpageprinter::status.

参照元 spoolss_hnd_startpageprinter().

01518 {
01519         prs_struct qbuf, rbuf;
01520         SPOOL_Q_STARTPAGEPRINTER in;
01521         SPOOL_R_STARTPAGEPRINTER out;
01522 
01523         ZERO_STRUCT(in);
01524         ZERO_STRUCT(out);
01525 
01526         make_spoolss_q_startpageprinter( &in, hnd );
01527 
01528         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_STARTPAGEPRINTER,
01529                     in, out, 
01530                     qbuf, rbuf,
01531                     spoolss_io_q_startpageprinter,
01532                     spoolss_io_r_startpageprinter, 
01533                     WERR_GENERAL_FAILURE );
01534                     
01535         return out.status;
01536 }

WERROR rpccli_spoolss_endpageprinter ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd 
)

cli_spoolss.c1541 行で定義されています。

参照先 climake_spoolss_q_endpageprinter()spoolss_io_q_endpageprinter()spoolss_io_r_endpageprinter()spool_r_endpageprinter::status.

参照元 spoolss_hnd_endpageprinter().

01543 {
01544         prs_struct qbuf, rbuf;
01545         SPOOL_Q_ENDPAGEPRINTER in;
01546         SPOOL_R_ENDPAGEPRINTER out;
01547 
01548         ZERO_STRUCT(in);
01549         ZERO_STRUCT(out);
01550 
01551         make_spoolss_q_endpageprinter( &in, hnd );
01552 
01553         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENDPAGEPRINTER,
01554                     in, out, 
01555                     qbuf, rbuf,
01556                     spoolss_io_q_endpageprinter,
01557                     spoolss_io_r_endpageprinter, 
01558                     WERR_GENERAL_FAILURE );
01559                     
01560         return out.status;
01561 }

WERROR rpccli_spoolss_startdocprinter ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
char *  docname,
char *  outputfile,
char *  datatype,
uint32 *  jobid 
)

cli_spoolss.c1566 行で定義されています。

参照先 clispool_r_startdocprinter::jobidlevelmake_spoolss_q_startdocprinter()spoolss_io_q_startdocprinter()spoolss_io_r_startdocprinter()spool_r_startdocprinter::status.

参照元 spoolss_hnd_startdocprinter().

01570 {
01571         prs_struct qbuf, rbuf;
01572         SPOOL_Q_STARTDOCPRINTER in;
01573         SPOOL_R_STARTDOCPRINTER out;
01574         uint32 level = 1;
01575 
01576         ZERO_STRUCT(in);
01577         ZERO_STRUCT(out);
01578 
01579         make_spoolss_q_startdocprinter( &in, hnd, level, docname, 
01580                 outputfile, datatype );
01581 
01582         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_STARTDOCPRINTER,
01583                     in, out, 
01584                     qbuf, rbuf,
01585                     spoolss_io_q_startdocprinter,
01586                     spoolss_io_r_startdocprinter, 
01587                     WERR_GENERAL_FAILURE );
01588 
01589         *jobid = out.jobid;
01590 
01591         return out.status;
01592 }

WERROR rpccli_spoolss_enddocprinter ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd 
)

cli_spoolss.c1597 行で定義されています。

参照先 climake_spoolss_q_enddocprinter()spoolss_io_q_enddocprinter()spoolss_io_r_enddocprinter()spool_r_enddocprinter::status.

参照元 spoolss_hnd_enddocprinter().

01599 {
01600         prs_struct qbuf, rbuf;
01601         SPOOL_Q_ENDDOCPRINTER in;
01602         SPOOL_R_ENDDOCPRINTER out;
01603 
01604         ZERO_STRUCT(in);
01605         ZERO_STRUCT(out);
01606 
01607         make_spoolss_q_enddocprinter( &in, hnd );
01608 
01609         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENDDOCPRINTER,
01610                     in, out, 
01611                     qbuf, rbuf,
01612                     spoolss_io_q_enddocprinter,
01613                     spoolss_io_r_enddocprinter, 
01614                     WERR_GENERAL_FAILURE );
01615                     
01616         return out.status;
01617 }

WERROR rpccli_spoolss_getprinterdata ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
const char *  valuename,
REGISTRY_VALUE value 
)

cli_spoolss.c1622 行で定義されています。

参照先 clispool_r_getprinterdata::dataREGISTRY_VALUE::data_pmake_spoolss_q_getprinterdata()spool_r_getprinterdata::neededspool_r_getprinterdata::sizeREGISTRY_VALUE::sizespoolss_io_q_getprinterdata()spoolss_io_r_getprinterdata()spool_r_getprinterdata::statusspool_r_getprinterdata::typeREGISTRY_VALUE::type.

参照元 cmd_spoolss_getprinterdata()spoolss_hnd_getprinterdata().

01625 {
01626         prs_struct qbuf, rbuf;
01627         SPOOL_Q_GETPRINTERDATA in;
01628         SPOOL_R_GETPRINTERDATA out;
01629         uint32 offered;
01630 
01631         ZERO_STRUCT(in);
01632         ZERO_STRUCT(out);
01633 
01634         offered = 0;
01635         make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
01636 
01637         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATA,
01638                     in, out, 
01639                     qbuf, rbuf,
01640                     spoolss_io_q_getprinterdata,
01641                     spoolss_io_r_getprinterdata, 
01642                     WERR_GENERAL_FAILURE );
01643 
01644         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
01645                 offered = out.needed;
01646                 
01647                 ZERO_STRUCT(in);
01648                 ZERO_STRUCT(out);
01649                 
01650                 make_spoolss_q_getprinterdata( &in, hnd, valuename, offered );
01651 
01652                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATA,
01653                             in, out, 
01654                             qbuf, rbuf,
01655                             spoolss_io_q_getprinterdata,
01656                             spoolss_io_r_getprinterdata, 
01657                             WERR_GENERAL_FAILURE );
01658         }
01659 
01660         if (!W_ERROR_IS_OK(out.status))
01661                 return out.status;      
01662 
01663         /* Return output parameters */
01664 
01665         if (out.needed) {
01666                 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
01667         } else {
01668                 value->data_p = NULL;
01669         }
01670         value->type = out.type;
01671         value->size = out.size;
01672 
01673         return out.status;
01674 }

WERROR rpccli_spoolss_getprinterdataex ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
const char *  keyname,
const char *  valuename,
REGISTRY_VALUE value 
)

cli_spoolss.c1679 行で定義されています。

参照先 clispool_r_getprinterdataex::dataREGISTRY_VALUE::data_pmake_spoolss_q_getprinterdataex()spool_r_getprinterdataex::neededREGISTRY_VALUE::sizespoolss_io_q_getprinterdataex()spoolss_io_r_getprinterdataex()spool_r_getprinterdataex::statusspool_r_getprinterdataex::typeREGISTRY_VALUE::type.

参照元 cmd_spoolss_getprinterdataex()spoolss_hnd_getprinterdataex().

01683 {
01684         prs_struct qbuf, rbuf;
01685         SPOOL_Q_GETPRINTERDATAEX in;
01686         SPOOL_R_GETPRINTERDATAEX out;
01687         uint32 offered = 0;
01688 
01689         ZERO_STRUCT(in);
01690         ZERO_STRUCT(out);
01691 
01692         make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
01693 
01694         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATAEX,
01695                     in, out, 
01696                     qbuf, rbuf,
01697                     spoolss_io_q_getprinterdataex,
01698                     spoolss_io_r_getprinterdataex, 
01699                     WERR_GENERAL_FAILURE );
01700 
01701         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
01702                 offered = out.needed;
01703                 
01704                 ZERO_STRUCT(in);
01705                 ZERO_STRUCT(out);
01706                 
01707                 make_spoolss_q_getprinterdataex( &in, hnd, keyname, valuename, offered );
01708 
01709                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_GETPRINTERDATAEX,
01710                             in, out, 
01711                             qbuf, rbuf,
01712                             spoolss_io_q_getprinterdataex,
01713                             spoolss_io_r_getprinterdataex, 
01714                             WERR_GENERAL_FAILURE );
01715         }
01716 
01717         if (!W_ERROR_IS_OK(out.status))
01718                 return out.status;      
01719 
01720         /* Return output parameters */
01721 
01722         if (out.needed) {
01723                 value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data, out.needed);
01724         } else {
01725                 value->data_p = NULL;
01726         }
01727         value->type = out.type;
01728         value->size = out.needed;
01729         
01730         return out.status;
01731 }

WERROR rpccli_spoolss_setprinterdata ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
REGISTRY_VALUE value 
)

cli_spoolss.c1736 行で定義されています。

参照先 cliREGISTRY_VALUE::data_pmake_spoolss_q_setprinterdata()REGISTRY_VALUE::sizespoolss_io_q_setprinterdata()spoolss_io_r_setprinterdata()spool_r_setprinterdata::statusREGISTRY_VALUE::typeREGISTRY_VALUE::valuename.

参照元 cmd_spoolss_setprinterdata()net_spoolss_setprinterdata()spoolss_hnd_setprinterdata().

01738 {
01739         prs_struct qbuf, rbuf;
01740         SPOOL_Q_SETPRINTERDATA in;
01741         SPOOL_R_SETPRINTERDATA out;
01742 
01743         ZERO_STRUCT(in);
01744         ZERO_STRUCT(out);
01745 
01746         make_spoolss_q_setprinterdata( &in, hnd, value->valuename, 
01747                 value->type, (char *)value->data_p, value->size);
01748 
01749         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTERDATA,
01750                     in, out, 
01751                     qbuf, rbuf,
01752                     spoolss_io_q_setprinterdata,
01753                     spoolss_io_r_setprinterdata, 
01754                     WERR_GENERAL_FAILURE );
01755                     
01756         return out.status;
01757 }

WERROR rpccli_spoolss_setprinterdataex ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
char *  keyname,
REGISTRY_VALUE value 
)

cli_spoolss.c1762 行で定義されています。

参照先 cliREGISTRY_VALUE::data_pmake_spoolss_q_setprinterdataex()REGISTRY_VALUE::sizespoolss_io_q_setprinterdataex()spoolss_io_r_setprinterdataex()spool_r_setprinterdataex::statusREGISTRY_VALUE::typeREGISTRY_VALUE::valuename.

参照元 net_spoolss_setprinterdataex()spoolss_hnd_setprinterdataex().

01765 {
01766         prs_struct qbuf, rbuf;
01767         SPOOL_Q_SETPRINTERDATAEX in;
01768         SPOOL_R_SETPRINTERDATAEX out;
01769         
01770         ZERO_STRUCT(in);
01771         ZERO_STRUCT(out);
01772 
01773         make_spoolss_q_setprinterdataex( &in, hnd, keyname, value->valuename, 
01774                 value->type, (char *)value->data_p, value->size);
01775 
01776         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_SETPRINTERDATAEX,
01777                     in, out, 
01778                     qbuf, rbuf,
01779                     spoolss_io_q_setprinterdataex,
01780                     spoolss_io_r_setprinterdataex, 
01781                     WERR_GENERAL_FAILURE );
01782 
01783         return out.status;
01784 }

WERROR rpccli_spoolss_enumprinterdata ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
uint32  ndx,
uint32  value_offered,
uint32  data_offered,
uint32 *  value_needed,
uint32 *  data_needed,
REGISTRY_VALUE value 
)

cli_spoolss.c1789 行で定義されています。

参照先 clispool_r_enumprinterdata::dataREGISTRY_VALUE::data_pmake_spoolss_q_enumprinterdata()spool_r_enumprinterdata::realdatasizespool_r_enumprinterdata::realvaluesizerpcstr_pull()REGISTRY_VALUE::sizespoolss_io_q_enumprinterdata()spoolss_io_r_enumprinterdata()spool_r_enumprinterdata::statusspool_r_enumprinterdata::typeREGISTRY_VALUE::typespool_r_enumprinterdata::valueREGISTRY_VALUE::valuename.

参照元 cmd_spoolss_enum_data()rpc_printer_migrate_settings_internals()spoolss_hnd_enumprinterdata().

01794 {
01795         prs_struct qbuf, rbuf;
01796         SPOOL_Q_ENUMPRINTERDATA in;
01797         SPOOL_R_ENUMPRINTERDATA out;
01798 
01799         ZERO_STRUCT(in);
01800         ZERO_STRUCT(out);
01801 
01802         make_spoolss_q_enumprinterdata( &in, hnd, ndx, value_offered, data_offered );
01803 
01804         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATA,
01805                     in, out, 
01806                     qbuf, rbuf,
01807                     spoolss_io_q_enumprinterdata,
01808                     spoolss_io_r_enumprinterdata, 
01809                     WERR_GENERAL_FAILURE );
01810 
01811         if ( value_needed )
01812                 *value_needed = out.realvaluesize;
01813         if ( data_needed )
01814                 *data_needed = out.realdatasize;
01815                 
01816         if (!W_ERROR_IS_OK(out.status))
01817                 return out.status;
01818 
01819         if (value) {
01820                 rpcstr_pull(value->valuename, out.value, sizeof(value->valuename), -1,
01821                             STR_TERMINATE);
01822                 if (out.realdatasize) {
01823                         value->data_p = (uint8 *)TALLOC_MEMDUP(mem_ctx, out.data,
01824                                                        out.realdatasize);
01825                 } else {
01826                         value->data_p = NULL;
01827                 }
01828                 value->type = out.type;
01829                 value->size = out.realdatasize;
01830         }
01831         
01832         return out.status;
01833 }

WERROR rpccli_spoolss_enumprinterdataex ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
const char *  keyname,
REGVAL_CTR ctr 
)

cli_spoolss.c1838 行で定義されています。

参照先 clispool_r_enumprinterdataex::ctrmake_spoolss_q_enumprinterdataex()namespool_r_enumprinterdataex::neededregval_ctr_addvalue()spool_r_enumprinterdataex::returnedrpcstr_pull()spoolss_io_q_enumprinterdataex()spoolss_io_r_enumprinterdataex()spool_r_enumprinterdataex::statusprinter_enum_values_ctr::values.

参照元 cmd_spoolss_enum_data_ex()get_remote_printer_publishing_data()net_spoolss_enumprinterdataex()spoolss_hnd_enumprinterdataex().

01841 {
01842         prs_struct qbuf, rbuf;
01843         SPOOL_Q_ENUMPRINTERDATAEX in;
01844         SPOOL_R_ENUMPRINTERDATAEX out;
01845         int i;
01846         uint32 offered;
01847 
01848         ZERO_STRUCT(in);
01849         ZERO_STRUCT(out);
01850 
01851         offered = 0;
01852         make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
01853 
01854         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATAEX,
01855                     in, out, 
01856                     qbuf, rbuf,
01857                     spoolss_io_q_enumprinterdataex,
01858                     spoolss_io_r_enumprinterdataex, 
01859                     WERR_GENERAL_FAILURE );
01860 
01861         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
01862                 offered = out.needed;
01863                 
01864                 ZERO_STRUCT(in);
01865                 ZERO_STRUCT(out);
01866                 
01867                 make_spoolss_q_enumprinterdataex( &in, hnd, keyname, offered );
01868 
01869                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERDATAEX,
01870                             in, out, 
01871                             qbuf, rbuf,
01872                             spoolss_io_q_enumprinterdataex,
01873                             spoolss_io_r_enumprinterdataex, 
01874                             WERR_GENERAL_FAILURE );
01875         }
01876         
01877         if (!W_ERROR_IS_OK(out.status))
01878                 return out.status;
01879 
01880         for (i = 0; i < out.returned; i++) {
01881                 PRINTER_ENUM_VALUES *v = &out.ctr.values[i];
01882                 fstring name;
01883 
01884                 rpcstr_pull(name, v->valuename.buffer, sizeof(name), -1, 
01885                             STR_TERMINATE);
01886                 regval_ctr_addvalue(ctr, name, v->type, (const char *)v->data, v->data_len);
01887         }
01888 
01889         return out.status;
01890 }

WERROR rpccli_spoolss_writeprinter ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
uint32  data_size,
char *  data,
uint32 *  num_written 
)

cli_spoolss.c1895 行で定義されています。

参照先 spool_r_writeprinter::buffer_writtenclimake_spoolss_q_writeprinter()spoolss_io_q_writeprinter()spoolss_io_r_writeprinter()spool_r_writeprinter::status.

参照元 spoolss_hnd_writeprinter().

01898 {
01899         prs_struct qbuf, rbuf;
01900         SPOOL_Q_WRITEPRINTER in;
01901         SPOOL_R_WRITEPRINTER out;
01902 
01903         ZERO_STRUCT(in);
01904         ZERO_STRUCT(out);
01905 
01906         make_spoolss_q_writeprinter( &in, hnd, data_size, data );
01907 
01908         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_WRITEPRINTER,
01909                     in, out, 
01910                     qbuf, rbuf,
01911                     spoolss_io_q_writeprinter,
01912                     spoolss_io_r_writeprinter, 
01913                     WERR_GENERAL_FAILURE );
01914                     
01915         if (num_written)
01916                 *num_written = out.buffer_written;
01917                 
01918         return out.status;
01919 }

WERROR rpccli_spoolss_deleteprinterdata ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
char *  valuename 
)

cli_spoolss.c1924 行で定義されています。

参照先 climake_spoolss_q_deleteprinterdata()spoolss_io_q_deleteprinterdata()spoolss_io_r_deleteprinterdata()spool_r_deleteprinterdata::status.

参照元 spoolss_hnd_deleteprinterdata().

01926 {
01927         prs_struct qbuf, rbuf;
01928         SPOOL_Q_DELETEPRINTERDATA in;
01929         SPOOL_R_DELETEPRINTERDATA out;
01930 
01931         ZERO_STRUCT(in);
01932         ZERO_STRUCT(out);
01933 
01934         make_spoolss_q_deleteprinterdata( &in, hnd, valuename );
01935 
01936         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDATA,
01937                     in, out, 
01938                     qbuf, rbuf,
01939                     spoolss_io_q_deleteprinterdata,
01940                     spoolss_io_r_deleteprinterdata, 
01941                     WERR_GENERAL_FAILURE );
01942 
01943         return out.status;
01944 }

WERROR rpccli_spoolss_deleteprinterdataex ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
char *  keyname,
char *  valuename 
)

cli_spoolss.c1949 行で定義されています。

参照先 climake_spoolss_q_deleteprinterdataex()spoolss_io_q_deleteprinterdataex()spoolss_io_r_deleteprinterdataex()spool_r_deleteprinterdataex::status.

参照元 spoolss_hnd_deleteprinterdataex().

01952 {
01953         prs_struct qbuf, rbuf;
01954         SPOOL_Q_DELETEPRINTERDATAEX in;
01955         SPOOL_R_DELETEPRINTERDATAEX out;
01956 
01957         ZERO_STRUCT(in);
01958         ZERO_STRUCT(out);
01959 
01960         make_spoolss_q_deleteprinterdataex( &in, hnd, keyname, valuename );
01961 
01962         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERDATAEX, 
01963                     in, out, 
01964                     qbuf, rbuf,
01965                     spoolss_io_q_deleteprinterdataex,
01966                     spoolss_io_r_deleteprinterdataex, 
01967                     WERR_GENERAL_FAILURE );
01968 
01969         return out.status;
01970 }

WERROR rpccli_spoolss_enumprinterkey ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
const char *  keyname,
uint16 **  keylist,
uint32 *  len 
)

cli_spoolss.c1975 行で定義されています。

参照先 BUFFER5::buf_lenBUFFER5::bufferclispool_r_enumprinterkey::keysmake_spoolss_q_enumprinterkey()spool_r_enumprinterkey::neededspoolss_io_q_enumprinterkey()spoolss_io_r_enumprinterkey()spool_r_enumprinterkey::status.

参照元 cmd_spoolss_enum_printerkey()net_spoolss_enumprinterkey()spoolss_hnd_enumprinterkey().

01978 {
01979         prs_struct qbuf, rbuf;
01980         SPOOL_Q_ENUMPRINTERKEY in;
01981         SPOOL_R_ENUMPRINTERKEY out;
01982         uint32 offered = 0;
01983 
01984         ZERO_STRUCT(in);
01985         ZERO_STRUCT(out);
01986 
01987         make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
01988 
01989         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERKEY, 
01990                     in, out, 
01991                     qbuf, rbuf,
01992                     spoolss_io_q_enumprinterkey,
01993                     spoolss_io_r_enumprinterkey, 
01994                     WERR_GENERAL_FAILURE );
01995 
01996         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
01997                 offered = out.needed;
01998                 
01999                 ZERO_STRUCT(in);
02000                 ZERO_STRUCT(out);
02001                 
02002                 make_spoolss_q_enumprinterkey( &in, hnd, keyname, offered );
02003 
02004                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_ENUMPRINTERKEY, 
02005                             in, out, 
02006                             qbuf, rbuf,
02007                             spoolss_io_q_enumprinterkey,
02008                             spoolss_io_r_enumprinterkey, 
02009                             WERR_GENERAL_FAILURE );
02010         }
02011 
02012         if ( !W_ERROR_IS_OK(out.status) )
02013                 return out.status;      
02014         
02015         if (keylist) {
02016                 *keylist = SMB_MALLOC_ARRAY(uint16, out.keys.buf_len);
02017                 if (!*keylist) {
02018                         return WERR_NOMEM;
02019                 }
02020                 memcpy(*keylist, out.keys.buffer, out.keys.buf_len * 2);
02021                 if (len)
02022                         *len = out.keys.buf_len * 2;
02023         }
02024 
02025         return out.status;
02026 }

WERROR rpccli_spoolss_deleteprinterkey ( struct rpc_pipe_client cli,
TALLOC_CTX mem_ctx,
POLICY_HND hnd,
char *  keyname 
)

cli_spoolss.c2031 行で定義されています。

参照先 climake_spoolss_q_deleteprinterkey()spoolss_io_q_deleteprinterkey()spoolss_io_r_deleteprinterkey()spool_r_deleteprinterkey::status.

02033 {
02034         prs_struct qbuf, rbuf;
02035         SPOOL_Q_DELETEPRINTERKEY in;
02036         SPOOL_R_DELETEPRINTERKEY out;
02037 
02038         ZERO_STRUCT(in);
02039         ZERO_STRUCT(out);
02040 
02041         make_spoolss_q_deleteprinterkey( &in, hnd, keyname );
02042 
02043         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SPOOLSS, SPOOLSS_DELETEPRINTERKEY, 
02044                     in, out, 
02045                     qbuf, rbuf,
02046                     spoolss_io_q_deleteprinterkey,
02047                     spoolss_io_r_deleteprinterkey, 
02048                     WERR_GENERAL_FAILURE );
02049                     
02050         return out.status;
02051 }


Sambaに対してSat Aug 29 21:24:07 2009に生成されました。  doxygen 1.4.7