backend/network.c

   1 /*
   2  * "$Id$"
   3  *
   4  * Common backend network APIs for CUPS.
   5  *
   6  * Copyright 2007-2011 by Apple Inc.
   7  * Copyright 2006-2007 by Easy Software Products, all rights reserved.
   8  *
   9  * These coded instructions, statements, and computer programs are the
  10  * property of Apple Inc. and are protected by Federal copyright
  11  * law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  12  * "LICENSE" which should have been included with this file.  If this
  13  * file is missing or damaged, see the license at "http://www.cups.org/".
  14  *
  15  * This file is subject to the Apple OS-Developed Software exception.
  16  */
  17
  18 /*
  19  * Include necessary headers.
  20  */
  21
  22 #include "backend-private.h"
  23 #include <limits.h>
  24 #include <sys/select.h>
  25
  26
  27 /*
  28  * 'backendCheckSideChannel()' - Check the side-channel for pending requests.
  29  */
  30
  31
  32 void
  33 backendCheckSideChannel(
  34     int         snmp_fd,                /* I - SNMP socket */
  35     http_addr_t *addr)                  /* I - Address of device */
  36 {
  37   fd_set        input;                  /* Select input set */
  38   struct timeval timeout;               /* Select timeout */
  39
  40
  41   FD_ZERO(&input);
  42   FD_SET(CUPS_SC_FD, &input);
  43
  44   timeout.tv_sec = timeout.tv_usec = 0;
  45
  46   if (select(CUPS_SC_FD + 1, &input, NULL, NULL, &timeout) > 0)
  47     backendNetworkSideCB(-1, -1, snmp_fd, addr, 0);
  48 }
  49
  50
  51 /*
  52  * 'backendNetworkSideCB()' - Handle common network side-channel commands.
  53  */
  54
  55 int                                     /* O - -1 on error, 0 on success */
  56 backendNetworkSideCB(
  57     int         print_fd,               /* I - Print file or -1 */
  58     int         device_fd,              /* I - Device file or -1 */
  59     int         snmp_fd,                /* I - SNMP socket */
  60     http_addr_t *addr,                  /* I - Address of device */
  61     int         use_bc)                 /* I - Use back-channel data? */
  62 {
  63   cups_sc_command_t     command;        /* Request command */
  64   cups_sc_status_t      status;         /* Request/response status */
  65   char                  data[65536];    /* Request/response data */
  66   int                   datalen;        /* Request/response data size */
  67   const char            *device_id;     /* 1284DEVICEID env var */
  68
  69
  70   datalen = sizeof(data);
  71
  72   if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))
  73     return (-1);
  74
  75   switch (command)
  76   {
  77     case CUPS_SC_CMD_DRAIN_OUTPUT :
  78        /*
  79         * Our sockets disable the Nagle algorithm and data is sent immediately.
  80         */
  81
  82         if (device_fd < 0)
  83           status = CUPS_SC_STATUS_NOT_IMPLEMENTED;
  84         else if (backendDrainOutput(print_fd, device_fd))
  85           status = CUPS_SC_STATUS_IO_ERROR;
  86         else
  87           status = CUPS_SC_STATUS_OK;
  88
  89         datalen = 0;
  90         break;
  91
  92     case CUPS_SC_CMD_GET_BIDI :
  93         status  = CUPS_SC_STATUS_OK;
  94         data[0] = use_bc;
  95         datalen = 1;
  96         break;
  97
  98     case CUPS_SC_CMD_SNMP_GET :
  99     case CUPS_SC_CMD_SNMP_GET_NEXT :
 100         fprintf(stderr, "DEBUG: CUPS_SC_CMD_SNMP_%s: %d (%s)\n",
 101                 command == CUPS_SC_CMD_SNMP_GET ? "GET" : "GET_NEXT", datalen,
 102                 data);
 103
 104         if (datalen < 2)
 105         {
 106           status  = CUPS_SC_STATUS_BAD_MESSAGE;
 107           datalen = 0;
 108           break;
 109         }
 110
 111         if (snmp_fd >= 0)
 112         {
 113           char          *dataptr;       /* Pointer into data */
 114           cups_snmp_t   packet;         /* Packet from printer */
 115           const char    *snmp_value;    /* CUPS_SNMP_VALUE env var */
 116
 117           if ((snmp_value = getenv("CUPS_SNMP_VALUE")) != NULL)
 118           {
 119             const char  *snmp_count;    /* CUPS_SNMP_COUNT env var */
 120             int         count;          /* Repetition count */
 121
 122             if ((snmp_count = getenv("CUPS_SNMP_COUNT")) != NULL)
 123             {
 124               if ((count = atoi(snmp_count)) <= 0)
 125                 count = 1;
 126             }
 127             else
 128               count = 1;
 129
 130             for (dataptr = data + strlen(data) + 1;
 131                  count > 0 && dataptr < (data + sizeof(data) - 1);
 132                  count --, dataptr += strlen(dataptr))
 133               strlcpy(dataptr, snmp_value, sizeof(data) - (dataptr - data));
 134
 135             fprintf(stderr, "DEBUG: Returning %s %s\n", data,
 136                     data + strlen(data) + 1);
 137
 138             status  = CUPS_SC_STATUS_OK;
 139             datalen = dataptr - data;
 140             break;
 141           }
 142
 143           if (!_cupsSNMPStringToOID(data, packet.object_name, CUPS_SNMP_MAX_OID))
 144           {
 145             status  = CUPS_SC_STATUS_BAD_MESSAGE;
 146             datalen = 0;
 147             break;
 148           }
 149
 150           status  = CUPS_SC_STATUS_IO_ERROR;
 151           datalen = 0;
 152
 153           if (_cupsSNMPWrite(snmp_fd, addr, CUPS_SNMP_VERSION_1,
 154                              _cupsSNMPDefaultCommunity(),
 155                              command == CUPS_SC_CMD_SNMP_GET ?
 156                                  CUPS_ASN1_GET_REQUEST :
 157                                  CUPS_ASN1_GET_NEXT_REQUEST, 1,
 158                              packet.object_name))
 159           {
 160             if (_cupsSNMPRead(snmp_fd, &packet, 1.0))
 161             {
 162               int       i;              /* Looping var */
 163
 164
 165               if (!_cupsSNMPOIDToString(packet.object_name, data, sizeof(data)))
 166               {
 167                 fputs("DEBUG: Bad OID returned!\n", stderr);
 168                 break;
 169               }
 170
 171               datalen = (int)strlen(data) + 1;
 172               dataptr = data + datalen;
 173
 174               switch (packet.object_type)
 175               {
 176                 case CUPS_ASN1_BOOLEAN :
 177                     snprintf(dataptr, sizeof(data) - (dataptr - data), "%d",
 178                              packet.object_value.boolean);
 179                     datalen += (int)strlen(dataptr);
 180                     break;
 181
 182                 case CUPS_ASN1_INTEGER :
 183                     snprintf(dataptr, sizeof(data) - (dataptr - data), "%d",
 184                              packet.object_value.integer);
 185                     datalen += (int)strlen(dataptr);
 186                     break;
 187
 188                 case CUPS_ASN1_BIT_STRING :
 189                 case CUPS_ASN1_OCTET_STRING :
 190                     if (packet.object_value.string.num_bytes < 0)
 191                       i = 0;
 192                     else if (packet.object_value.string.num_bytes <
 193                              (sizeof(data) - (dataptr - data)))
 194                       i = packet.object_value.string.num_bytes;
 195                     else
 196                       i = (int)(sizeof(data) - (dataptr - data));
 197
 198                     memcpy(dataptr, packet.object_value.string.bytes, i);
 199
 200                     datalen += i;
 201                     break;
 202
 203                 case CUPS_ASN1_OID :
 204                     _cupsSNMPOIDToString(packet.object_value.oid, dataptr,
 205                                          sizeof(data) - (dataptr - data));
 206                     datalen += (int)strlen(dataptr);
 207                     break;
 208
 209                 case CUPS_ASN1_HEX_STRING :
 210                     for (i = 0;
 211                          i < packet.object_value.string.num_bytes &&
 212                              dataptr < (data + sizeof(data) - 3);
 213                          i ++, dataptr += 2)
 214                       sprintf(dataptr, "%02X",
 215                               packet.object_value.string.bytes[i]);
 216                     datalen += (int)strlen(dataptr);
 217                     break;
 218
 219                 case CUPS_ASN1_COUNTER :
 220                     snprintf(dataptr, sizeof(data) - (dataptr - data), "%d",
 221                              packet.object_value.counter);
 222                     datalen += (int)strlen(dataptr);
 223                     break;
 224
 225                 case CUPS_ASN1_GAUGE :
 226                     snprintf(dataptr, sizeof(data) - (dataptr - data), "%u",
 227                              packet.object_value.gauge);
 228                     datalen += (int)strlen(dataptr);
 229                     break;
 230
 231                 case CUPS_ASN1_TIMETICKS :
 232                     snprintf(dataptr, sizeof(data) - (dataptr - data), "%u",
 233                              packet.object_value.timeticks);
 234                     datalen += (int)strlen(dataptr);
 235                     break;
 236
 237                 default :
 238                     fprintf(stderr, "DEBUG: Unknown OID value type %02X!\n",
 239                             packet.object_type);
 240
 241                 case CUPS_ASN1_NULL_VALUE :
 242                     dataptr[0] = '\0';
 243                     break;
 244               }
 245
 246               fprintf(stderr, "DEBUG: Returning %s %s\n", data, data + datalen);
 247
 248               status = CUPS_SC_STATUS_OK;
 249             }
 250             else
 251               fputs("DEBUG: SNMP read error...\n", stderr);
 252           }
 253           else
 254             fputs("DEBUG: SNMP write error...\n", stderr);
 255           break;
 256         }
 257
 258         status  = CUPS_SC_STATUS_NOT_IMPLEMENTED;
 259         datalen = 0;
 260         break;
 261
 262     case CUPS_SC_CMD_GET_DEVICE_ID :
 263         if (snmp_fd >= 0)
 264         {
 265           cups_snmp_t   packet;         /* Packet from printer */
 266           static const int ppmPrinterIEEE1284DeviceId[] =
 267                         { CUPS_OID_ppmPrinterIEEE1284DeviceId,1,-1 };
 268
 269
 270           status  = CUPS_SC_STATUS_IO_ERROR;
 271           datalen = 0;
 272
 273           if (_cupsSNMPWrite(snmp_fd, addr, CUPS_SNMP_VERSION_1,
 274                              _cupsSNMPDefaultCommunity(),
 275                              CUPS_ASN1_GET_REQUEST, 1,
 276                              ppmPrinterIEEE1284DeviceId))
 277           {
 278             if (_cupsSNMPRead(snmp_fd, &packet, 1.0) &&
 279                 packet.object_type == CUPS_ASN1_OCTET_STRING)
 280             {
 281               strlcpy(data, (char *)packet.object_value.string.bytes,
 282                       sizeof(data));
 283               datalen = (int)strlen(data);
 284               status  = CUPS_SC_STATUS_OK;
 285             }
 286           }
 287
 288           break;
 289         }
 290
 291         if ((device_id = getenv("1284DEVICEID")) != NULL)
 292         {
 293           strlcpy(data, device_id, sizeof(data));
 294           datalen = (int)strlen(data);
 295           status  = CUPS_SC_STATUS_OK;
 296           break;
 297         }
 298
 299     case CUPS_SC_CMD_GET_CONNECTED :
 300         status  = CUPS_SC_STATUS_OK;
 301         data[0] = device_fd != -1;
 302         datalen = 1;
 303         break;
 304
 305     default :
 306         status  = CUPS_SC_STATUS_NOT_IMPLEMENTED;
 307         datalen = 0;
 308         break;
 309   }
 310
 311   return (cupsSideChannelWrite(command, status, data, datalen, 1.0));
 312 }
 313
 314
 315 /*
 316  * End of "$Id$".
 317  */