lib/libncp/ncpl_queue.c

   1 /*
   2  * Copyright (c) 1999, Boris Popov
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *    This product includes software developed by Boris Popov.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * $FreeBSD: src/lib/libncp/ncpl_queue.c,v 1.2 1999/10/31 03:39:03 bp Exp $
  33  *
  34  * NetWare queue interface
  35  *
  36  */
  37 #include <sys/types.h>
  38 #include <errno.h>
  39 #include <stdio.h>
  40 #include <netncp/ncp_lib.h>
  41
  42 int
  43 ncp_create_queue_job_and_file(NWCONN_HANDLE connid, u_int32_t queue_id,
  44         struct queue_job *job)
  45 {
  46         int error;
  47         DECLARE_RQ;
  48
  49         ncp_init_request_s(conn, 121);
  50         ncp_add_dword_hl(conn, queue_id);
  51         ncp_add_mem(conn, &(job->j), sizeof(job->j));
  52
  53         if ((error = ncp_request(connid, 23, conn)) != 0)
  54                 return error;
  55         memcpy(&(job->j), ncp_reply_data(conn, 0), 78);
  56         ConvertToNWfromDWORD(job->j.JobFileHandle, &job->file_handle);
  57         return 0;
  58 }
  59
  60 int
  61 ncp_close_file_and_start_job(NWCONN_HANDLE connid, u_int32_t queue_id,
  62         struct queue_job *job)
  63 {
  64         int error;
  65         DECLARE_RQ;
  66
  67         ncp_init_request_s(conn, 127);
  68         ncp_add_dword_hl(conn, queue_id);
  69         ncp_add_dword_lh(conn, job->j.JobNumber);
  70         error = ncp_request(connid, 23, conn);
  71         return error;
  72 }
  73
  74 int
  75 ncp_attach_to_queue(NWCONN_HANDLE connid, u_int32_t queue_id) {
  76         int error;
  77         DECLARE_RQ;
  78
  79         ncp_init_request_s(conn, 111);
  80         ncp_add_dword_hl(conn, queue_id);
  81         error = ncp_request(connid, 23, conn);
  82         return error;
  83 }
  84
  85 int
  86 ncp_detach_from_queue(NWCONN_HANDLE connid, u_int32_t queue_id) {
  87         int error;
  88         DECLARE_RQ;
  89
  90         ncp_init_request_s(conn, 112);
  91         ncp_add_dword_hl(conn, queue_id);
  92         error= ncp_request(connid, 23, conn);
  93         return error;
  94 }
  95
  96 int
  97 ncp_service_queue_job(NWCONN_HANDLE connid, u_int32_t queue_id,
  98         u_int16_t job_type, struct queue_job *job)
  99 {
 100         int error;
 101         DECLARE_RQ;
 102
 103         ncp_init_request_s(conn, 124);
 104         ncp_add_dword_hl(conn, queue_id);
 105         ncp_add_word_hl(conn, job_type);
 106         if ((error = ncp_request(connid, 23, conn)) != 0) {
 107                 return error;
 108         }
 109         memcpy(&(job->j), ncp_reply_data(conn, 0), 78);
 110         ConvertToNWfromDWORD(job->j.JobFileHandle, &job->file_handle);
 111         return error;
 112 }
 113
 114 int
 115 ncp_finish_servicing_job(NWCONN_HANDLE connid, u_int32_t queue_id,
 116         u_int32_t job_number, u_int32_t charge_info)
 117 {
 118         int error;
 119         DECLARE_RQ;
 120
 121         ncp_init_request_s(conn, 131);
 122         ncp_add_dword_hl(conn, queue_id);
 123         ncp_add_dword_lh(conn, job_number);
 124         ncp_add_dword_hl(conn, charge_info);
 125
 126         error = ncp_request(connid, 23, conn);
 127         return error;
 128 }
 129
 130 int
 131 ncp_abort_servicing_job(NWCONN_HANDLE connid, u_int32_t queue_id,
 132         u_int32_t job_number)
 133 {
 134         int error;
 135         DECLARE_RQ;
 136
 137         ncp_init_request_s(conn, 132);
 138         ncp_add_dword_hl(conn, queue_id);
 139         ncp_add_dword_lh(conn, job_number);
 140         error = ncp_request(connid, 23, conn);
 141         return error;
 142 }
 143
 144 int
 145 ncp_get_queue_length(NWCONN_HANDLE connid, u_int32_t queue_id,
 146         u_int32_t *queue_length)
 147 {
 148         int error;
 149         DECLARE_RQ;
 150
 151         ncp_init_request_s(conn, 125);
 152         ncp_add_dword_hl(conn, queue_id);
 153
 154         if ((error = ncp_request(connid, 23, conn)) != 0)
 155                 return error;
 156         if (conn->rpsize < 12) {
 157                 ncp_printf("ncp_reply_size %d < 12\n", conn->rpsize);
 158                 return EINVAL;
 159         }
 160         if (ncp_reply_dword_hl(conn,0) != queue_id) {
 161                 printf("Ouch! Server didn't reply with same queue id in ncp_get_queue_length!\n");
 162                 return EINVAL;
 163         }
 164         *queue_length = ncp_reply_dword_lh(conn,8);
 165         return error;
 166 }
 167
 168 int
 169 ncp_get_queue_job_ids(NWCONN_HANDLE connid, u_int32_t queue_id,
 170         u_int32_t queue_section, u_int32_t *length1, u_int32_t *length2,
 171         u_int32_t ids[])
 172 {
 173         int error;
 174         DECLARE_RQ;
 175
 176         ncp_init_request_s(conn,129);
 177         ncp_add_dword_hl(conn, queue_id);
 178         ncp_add_dword_lh(conn, queue_section);
 179
 180         if ((error = ncp_request(connid, 23, conn)) != 0)
 181                 return error;
 182         if (conn->rpsize < 8) {
 183                 ncp_printf("ncp_reply_size %d < 8\n", conn->rpsize);
 184                 return EINVAL;
 185         }
 186         *length2 = ncp_reply_dword_lh(conn,4);
 187         if (conn->rpsize < 8 + 4*(*length2)) {
 188                 ncp_printf("ncp_reply_size %d < %d\n", conn->rpsize, 8+4*(*length2));
 189                 return EINVAL;
 190         }
 191         if (ids) {
 192                 int count = min(*length1, *length2)*sizeof(u_int32_t);
 193                 int pos;
 194
 195                 for (pos=0; pos<count; pos+=sizeof(u_int32_t)) {
 196                         *ids++ = ncp_reply_dword_lh(conn, 8+pos);
 197                 }
 198         }
 199         *length1 = ncp_reply_dword_lh(conn,0);
 200         return error;
 201 }
 202
 203 int
 204 ncp_get_queue_job_info(NWCONN_HANDLE connid, u_int32_t queue_id,
 205         u_int32_t job_id, struct nw_queue_job_entry *jobdata)
 206 {
 207         int error;
 208         DECLARE_RQ;
 209
 210         ncp_init_request_s(conn,122);
 211         ncp_add_dword_hl(conn, queue_id);
 212         ncp_add_dword_lh(conn, job_id);
 213
 214         if ((error = ncp_request(connid, 23, conn)) != 0)
 215                 return error;
 216
 217         if (conn->rpsize < sizeof(struct nw_queue_job_entry)) {
 218                 ncp_printf("ncp_reply_size %d < %d\n", conn->rpsize,sizeof(struct nw_queue_job_entry));
 219                 return EINVAL;
 220         }
 221         memcpy(jobdata,ncp_reply_data(conn,0), sizeof(struct nw_queue_job_entry));
 222         return error;
 223 }