#include "cups-private.h"
#include "snmp-private.h"
#ifdef HAVE_POLL
# include <poll.h>
#endif
static void asn1_debug(const char *prefix, unsigned char *buffer,
size_t len, int indent);
static int asn1_decode_snmp(unsigned char *buffer, size_t len,
cups_snmp_t *packet);
static int asn1_encode_snmp(unsigned char *buffer, size_t len,
cups_snmp_t *packet);
static int asn1_get_integer(unsigned char **buffer,
unsigned char *bufend,
int length);
static int asn1_get_oid(unsigned char **buffer,
unsigned char *bufend,
int length, int *oid, int oidsize);
static int asn1_get_packed(unsigned char **buffer,
unsigned char *bufend);
static char *asn1_get_string(unsigned char **buffer,
unsigned char *bufend,
int length, char *string,
int strsize);
static unsigned asn1_get_length(unsigned char **buffer,
unsigned char *bufend);
static int asn1_get_type(unsigned char **buffer,
unsigned char *bufend);
static void asn1_set_integer(unsigned char **buffer,
int integer);
static void asn1_set_length(unsigned char **buffer,
unsigned length);
static void asn1_set_oid(unsigned char **buffer,
const int *oid);
static void asn1_set_packed(unsigned char **buffer,
int integer);
static int asn1_size_integer(int integer);
static int asn1_size_length(int length);
static int asn1_size_oid(const int *oid);
static int asn1_size_packed(int integer);
static void snmp_set_error(cups_snmp_t *packet,
const char *message);
void
_cupsSNMPClose(int fd)
{
DEBUG_printf(("4_cupsSNMPClose(fd=%d)", fd));
#ifdef WIN32
closesocket(fd);
#else
close(fd);
#endif
}
int *
_cupsSNMPCopyOID(int *dst,
const int *src,
int dstsize)
{
int i;
DEBUG_printf(("4_cupsSNMPCopyOID(dst=%p, src=%p, dstsize=%d)", dst, src,
dstsize));
for (i = 0, dstsize --; src[i] >= 0 && i < dstsize; i ++)
dst[i] = src[i];
dst[i] = -1;
return (dst);
}
const char *
_cupsSNMPDefaultCommunity(void)
{
cups_file_t *fp;
char line[1024],
*value;
int linenum;
_cups_globals_t *cg = _cupsGlobals();
DEBUG_puts("4_cupsSNMPDefaultCommunity()");
if (!cg->snmp_community[0])
{
strlcpy(cg->snmp_community, "public", sizeof(cg->snmp_community));
snprintf(line, sizeof(line), "%s/snmp.conf", cg->cups_serverroot);
if ((fp = cupsFileOpen(line, "r")) != NULL)
{
linenum = 0;
while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
if (!_cups_strcasecmp(line, "Community") && value)
{
strlcpy(cg->snmp_community, value, sizeof(cg->snmp_community));
break;
}
cupsFileClose(fp);
}
}
DEBUG_printf(("5_cupsSNMPDefaultCommunity: Returning \"%s\"",
cg->snmp_community));
return (cg->snmp_community);
}
int
_cupsSNMPIsOID(cups_snmp_t *packet,
const int *oid)
{
int i;
DEBUG_printf(("4_cupsSNMPIsOID(packet=%p, oid=%p)", packet, oid));
if (!packet || !oid)
{
DEBUG_puts("5_cupsSNMPIsOID: Returning 0");
return (0);
}
for (i = 0;
i < CUPS_SNMP_MAX_OID && oid[i] >= 0 && packet->object_name[i] >= 0;
i ++)
if (oid[i] != packet->object_name[i])
{
DEBUG_puts("5_cupsSNMPIsOID: Returning 0");
return (0);
}
DEBUG_printf(("5_cupsSNMPIsOID: Returning %d",
i < CUPS_SNMP_MAX_OID && oid[i] == packet->object_name[i]));
return (i < CUPS_SNMP_MAX_OID && oid[i] == packet->object_name[i]);
}
int
_cupsSNMPIsOIDPrefixed(
cups_snmp_t *packet,
const int *prefix)
{
int i;
DEBUG_printf(("4_cupsSNMPIsOIDPrefixed(packet=%p, prefix=%p)", packet,
prefix));
if (!packet || !prefix)
{
DEBUG_puts("5_cupsSNMPIsOIDPrefixed: Returning 0");
return (0);
}
for (i = 0;
i < CUPS_SNMP_MAX_OID && prefix[i] >= 0 && packet->object_name[i] >= 0;
i ++)
if (prefix[i] != packet->object_name[i])
{
DEBUG_puts("5_cupsSNMPIsOIDPrefixed: Returning 0");
return (0);
}
DEBUG_printf(("5_cupsSNMPIsOIDPrefixed: Returning %d",
i < CUPS_SNMP_MAX_OID));
return (i < CUPS_SNMP_MAX_OID);
}
char *
_cupsSNMPOIDToString(const int *src,
char *dst,
size_t dstsize)
{
char *dstptr,
*dstend;
DEBUG_printf(("4_cupsSNMPOIDToString(src=%p, dst=%p, dstsize=" CUPS_LLFMT ")",
src, dst, CUPS_LLCAST dstsize));
if (!src || !dst || dstsize < 4)
return (NULL);
for (dstptr = dst, dstend = dstptr + dstsize - 1;
*src >= 0 && dstptr < dstend;
src ++, dstptr += strlen(dstptr))
snprintf(dstptr, dstend - dstptr + 1, ".%d", *src);
if (*src >= 0)
return (NULL);
else
return (dst);
}
int
_cupsSNMPOpen(int family)
{
int fd;
int val;
DEBUG_printf(("4_cupsSNMPOpen(family=%d)", family));
if ((fd = socket(family, SOCK_DGRAM, 0)) < 0)
{
DEBUG_printf(("5_cupsSNMPOpen: Returning -1 (%s)", strerror(errno)));
return (-1);
}
val = 1;
#ifdef WIN32
if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (char *)&val, sizeof(val)))
#else
if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &val, sizeof(val)))
#endif
{
DEBUG_printf(("5_cupsSNMPOpen: Returning -1 (%s)", strerror(errno)));
close(fd);
return (-1);
}
DEBUG_printf(("5_cupsSNMPOpen: Returning %d", fd));
return (fd);
}
cups_snmp_t *
_cupsSNMPRead(int fd,
cups_snmp_t *packet,
double timeout)
{
unsigned char buffer[CUPS_SNMP_MAX_PACKET];
int bytes;
socklen_t addrlen;
http_addr_t address;
DEBUG_printf(("4_cupsSNMPRead(fd=%d, packet=%p, timeout=%.1f)", fd, packet,
timeout));
if (fd < 0 || !packet)
{
DEBUG_puts("5_cupsSNMPRead: Returning NULL");
return (NULL);
}
if (timeout >= 0.0)
{
int ready;
#ifdef HAVE_POLL
struct pollfd pfd;
pfd.fd = fd;
pfd.events = POLLIN;
while ((ready = poll(&pfd, 1, (int)(timeout * 1000.0))) < 0 &&
(errno == EINTR || errno == EAGAIN));
#else
fd_set input_set;
struct timeval stimeout;
do
{
FD_ZERO(&input_set);
FD_SET(fd, &input_set);
stimeout.tv_sec = (int)timeout;
stimeout.tv_usec = (int)((timeout - stimeout.tv_sec) * 1000000);
ready = select(fd + 1, &input_set, NULL, NULL, &stimeout);
}
# ifdef WIN32
while (ready < 0 && WSAGetLastError() == WSAEINTR);
# else
while (ready < 0 && (errno == EINTR || errno == EAGAIN));
# endif
#endif
if (ready <= 0)
{
DEBUG_puts("5_cupsSNMPRead: Returning NULL (timeout)");
return (NULL);
}
}
addrlen = sizeof(address);
if ((bytes = recvfrom(fd, buffer, sizeof(buffer), 0, (void *)&address,
&addrlen)) < 0)
{
DEBUG_printf(("5_cupsSNMPRead: Returning NULL (%s)", strerror(errno)));
return (NULL);
}
asn1_debug("DEBUG: IN ", buffer, bytes, 0);
asn1_decode_snmp(buffer, bytes, packet);
memcpy(&(packet->address), &address, sizeof(packet->address));
DEBUG_puts("5_cupsSNMPRead: Returning packet");
return (packet);
}
void
_cupsSNMPSetDebug(int level)
{
_cups_globals_t *cg = _cupsGlobals();
DEBUG_printf(("4_cupsSNMPSetDebug(level=%d)", level));
cg->snmp_debug = level;
}
int *
_cupsSNMPStringToOID(const char *src,
int *dst,
int dstsize)
{
int *dstptr,
*dstend;
DEBUG_printf(("4_cupsSNMPStringToOID(src=\"%s\", dst=%p, dstsize=%d)",
src, dst, dstsize));
if (!src || !dst || dstsize < 2)
return (NULL);
if (*src == '.')
src ++;
for (dstend = dst + dstsize - 1, dstptr = dst, *dstptr = 0;
*src && dstptr < dstend;
src ++)
{
if (*src == '.')
{
dstptr ++;
*dstptr = 0;
}
else if (isdigit(*src & 255))
*dstptr = *dstptr * 10 + *src - '0';
else
break;
}
if (*src)
return (NULL);
dstptr[1] = -1;
return (dst);
}
int
_cupsSNMPWalk(int fd,
http_addr_t *address,
int version,
const char *community,
const int *prefix,
double timeout,
cups_snmp_cb_t cb,
void *data)
{
int count = 0;
int request_id = 0;
cups_snmp_t packet;
int lastoid[CUPS_SNMP_MAX_OID];
DEBUG_printf(("4_cupsSNMPWalk(fd=%d, address=%p, version=%d, "
"community=\"%s\", prefix=%p, timeout=%.1f, cb=%p, data=%p)",
fd, address, version, community, prefix, timeout, cb, data));
if (fd < 0 || !address || version != CUPS_SNMP_VERSION_1 || !community ||
!prefix || !cb)
{
DEBUG_puts("5_cupsSNMPWalk: Returning -1");
return (-1);
}
_cupsSNMPCopyOID(packet.object_name, prefix, CUPS_SNMP_MAX_OID);
lastoid[0] = -1;
for (;;)
{
request_id ++;
if (!_cupsSNMPWrite(fd, address, version, community,
CUPS_ASN1_GET_NEXT_REQUEST, request_id,
packet.object_name))
{
DEBUG_puts("5_cupsSNMPWalk: Returning -1");
return (-1);
}
if (!_cupsSNMPRead(fd, &packet, timeout))
{
DEBUG_puts("5_cupsSNMPWalk: Returning -1");
return (-1);
}
if (!_cupsSNMPIsOIDPrefixed(&packet, prefix) ||
_cupsSNMPIsOID(&packet, lastoid))
{
DEBUG_printf(("5_cupsSNMPWalk: Returning %d", count));
return (count);
}
if (packet.error || packet.error_status)
{
DEBUG_printf(("5_cupsSNMPWalk: Returning %d", count > 0 ? count : -1));
return (count > 0 ? count : -1);
}
_cupsSNMPCopyOID(lastoid, packet.object_name, CUPS_SNMP_MAX_OID);
count ++;
(*cb)(&packet, data);
}
}
int
_cupsSNMPWrite(
int fd,
http_addr_t *address,
int version,
const char *community,
cups_asn1_t request_type,
const unsigned request_id,
const int *oid)
{
int i;
cups_snmp_t packet;
unsigned char buffer[CUPS_SNMP_MAX_PACKET];
int bytes;
http_addr_t temp;
DEBUG_printf(("4_cupsSNMPWrite(fd=%d, address=%p, version=%d, "
"community=\"%s\", request_type=%d, request_id=%u, oid=%p)",
fd, address, version, community, request_type, request_id, oid));
if (fd < 0 || !address || version != CUPS_SNMP_VERSION_1 || !community ||
(request_type != CUPS_ASN1_GET_REQUEST &&
request_type != CUPS_ASN1_GET_NEXT_REQUEST) || request_id < 1 || !oid)
{
DEBUG_puts("5_cupsSNMPWrite: Returning 0 (bad arguments)");
return (0);
}
memset(&packet, 0, sizeof(packet));
packet.version = version;
packet.request_type = request_type;
packet.request_id = request_id;
packet.object_type = CUPS_ASN1_NULL_VALUE;
strlcpy(packet.community, community, sizeof(packet.community));
for (i = 0; oid[i] >= 0 && i < (CUPS_SNMP_MAX_OID - 1); i ++)
packet.object_name[i] = oid[i];
packet.object_name[i] = -1;
if (oid[i] >= 0)
{
DEBUG_puts("5_cupsSNMPWrite: Returning 0 (OID too big)");
errno = E2BIG;
return (0);
}
bytes = asn1_encode_snmp(buffer, sizeof(buffer), &packet);
if (bytes < 0)
{
DEBUG_puts("5_cupsSNMPWrite: Returning 0 (request too big)");
errno = E2BIG;
return (0);
}
asn1_debug("DEBUG: OUT ", buffer, bytes, 0);
temp = *address;
_httpAddrSetPort(&temp, CUPS_SNMP_PORT);
return (sendto(fd, buffer, bytes, 0, (void *)&temp,
httpAddrLength(&temp)) == bytes);
}
static void
asn1_debug(const char *prefix,
unsigned char *buffer,
size_t len,
int indent)
{
int i;
unsigned char *bufend;
int integer;
int oid[CUPS_SNMP_MAX_OID];
char string[CUPS_SNMP_MAX_STRING];
unsigned char value_type;
int value_length;
_cups_globals_t *cg = _cupsGlobals();
if (cg->snmp_debug <= 0)
return;
if (cg->snmp_debug > 1 && indent == 0)
{
int j;
fprintf(stderr, "%sHex Dump (%d bytes):\n", prefix, (int)len);
for (i = 0; i < (int)len; i += 16)
{
fprintf(stderr, "%s%04x:", prefix, i);
for (j = 0; j < 16 && (i + j) < (int)len; j ++)
{
if (j && !(j & 3))
fprintf(stderr, " %02x", buffer[i + j]);
else
fprintf(stderr, " %02x", buffer[i + j]);
}
while (j < 16)
{
if (j && !(j & 3))
fputs(" ", stderr);
else
fputs(" ", stderr);
j ++;
}
fputs(" ", stderr);
for (j = 0; j < 16 && (i + j) < (int)len; j ++)
if (buffer[i + j] < ' ' || buffer[i + j] >= 0x7f)
putc('.', stderr);
else
putc(buffer[i + j], stderr);
putc('\n', stderr);
}
}
if (indent == 0)
fprintf(stderr, "%sMessage:\n", prefix);
bufend = buffer + len;
while (buffer < bufend)
{
value_type = asn1_get_type(&buffer, bufend);
value_length = asn1_get_length(&buffer, bufend);
switch (value_type)
{
case CUPS_ASN1_BOOLEAN :
integer = asn1_get_integer(&buffer, bufend, value_length);
fprintf(stderr, "%s%*sBOOLEAN %d bytes %d\n", prefix, indent, "",
value_length, integer);
break;
case CUPS_ASN1_INTEGER :
integer = asn1_get_integer(&buffer, bufend, value_length);
fprintf(stderr, "%s%*sINTEGER %d bytes %d\n", prefix, indent, "",
value_length, integer);
break;
case CUPS_ASN1_COUNTER :
integer = asn1_get_integer(&buffer, bufend, value_length);
fprintf(stderr, "%s%*sCOUNTER %d bytes %u\n", prefix, indent, "",
value_length, (unsigned)integer);
break;
case CUPS_ASN1_GAUGE :
integer = asn1_get_integer(&buffer, bufend, value_length);
fprintf(stderr, "%s%*sGAUGE %d bytes %u\n", prefix, indent, "",
value_length, (unsigned)integer);
break;
case CUPS_ASN1_TIMETICKS :
integer = asn1_get_integer(&buffer, bufend, value_length);
fprintf(stderr, "%s%*sTIMETICKS %d bytes %u\n", prefix, indent, "",
value_length, (unsigned)integer);
break;
case CUPS_ASN1_OCTET_STRING :
fprintf(stderr, "%s%*sOCTET STRING %d bytes \"%s\"\n", prefix,
indent, "", value_length,
asn1_get_string(&buffer, bufend, value_length, string,
sizeof(string)));
break;
case CUPS_ASN1_HEX_STRING :
asn1_get_string(&buffer, bufend, value_length, string,
sizeof(string));
fprintf(stderr, "%s%*sHex-STRING %d bytes", prefix,
indent, "", value_length);
for (i = 0; i < value_length; i ++)
fprintf(stderr, " %02X", string[i] & 255);
putc('\n', stderr);
break;
case CUPS_ASN1_NULL_VALUE :
fprintf(stderr, "%s%*sNULL VALUE %d bytes\n", prefix, indent, "",
value_length);
buffer += value_length;
break;
case CUPS_ASN1_OID :
integer = asn1_get_oid(&buffer, bufend, value_length, oid,
CUPS_SNMP_MAX_OID);
fprintf(stderr, "%s%*sOID %d bytes ", prefix, indent, "",
value_length);
for (i = 0; i < integer; i ++)
fprintf(stderr, ".%d", oid[i]);
putc('\n', stderr);
break;
case CUPS_ASN1_SEQUENCE :
fprintf(stderr, "%s%*sSEQUENCE %d bytes\n", prefix, indent, "",
value_length);
asn1_debug(prefix, buffer, value_length, indent + 4);
buffer += value_length;
break;
case CUPS_ASN1_GET_NEXT_REQUEST :
fprintf(stderr, "%s%*sGet-Next-Request-PDU %d bytes\n", prefix,
indent, "", value_length);
asn1_debug(prefix, buffer, value_length, indent + 4);
buffer += value_length;
break;
case CUPS_ASN1_GET_REQUEST :
fprintf(stderr, "%s%*sGet-Request-PDU %d bytes\n", prefix, indent, "",
value_length);
asn1_debug(prefix, buffer, value_length, indent + 4);
buffer += value_length;
break;
case CUPS_ASN1_GET_RESPONSE :
fprintf(stderr, "%s%*sGet-Response-PDU %d bytes\n", prefix, indent,
"", value_length);
asn1_debug(prefix, buffer, value_length, indent + 4);
buffer += value_length;
break;
default :
fprintf(stderr, "%s%*sUNKNOWN(%x) %d bytes\n", prefix, indent, "",
value_type, value_length);
buffer += value_length;
break;
}
}
}
static int
asn1_decode_snmp(unsigned char *buffer,
size_t len,
cups_snmp_t *packet)
{
unsigned char *bufptr,
*bufend;
int length;
memset(packet, 0, sizeof(cups_snmp_t));
packet->object_name[0] = -1;
bufptr = buffer;
bufend = buffer + len;
if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_SEQUENCE)
snmp_set_error(packet, _("Packet does not start with SEQUENCE"));
else if (asn1_get_length(&bufptr, bufend) == 0)
snmp_set_error(packet, _("SEQUENCE uses indefinite length"));
else if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_INTEGER)
snmp_set_error(packet, _("No version number"));
else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
snmp_set_error(packet, _("Version uses indefinite length"));
else if ((packet->version = asn1_get_integer(&bufptr, bufend, length))
!= CUPS_SNMP_VERSION_1)
snmp_set_error(packet, _("Bad SNMP version number"));
else if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_OCTET_STRING)
snmp_set_error(packet, _("No community name"));
else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
snmp_set_error(packet, _("Community name uses indefinite length"));
else
{
asn1_get_string(&bufptr, bufend, length, packet->community,
sizeof(packet->community));
if ((packet->request_type = asn1_get_type(&bufptr, bufend))
!= CUPS_ASN1_GET_RESPONSE)
snmp_set_error(packet, _("Packet does not contain a Get-Response-PDU"));
else if (asn1_get_length(&bufptr, bufend) == 0)
snmp_set_error(packet, _("Get-Response-PDU uses indefinite length"));
else if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_INTEGER)
snmp_set_error(packet, _("No request-id"));
else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
snmp_set_error(packet, _("request-id uses indefinite length"));
else
{
packet->request_id = asn1_get_integer(&bufptr, bufend, length);
if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_INTEGER)
snmp_set_error(packet, _("No error-status"));
else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
snmp_set_error(packet, _("error-status uses indefinite length"));
else
{
packet->error_status = asn1_get_integer(&bufptr, bufend, length);
if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_INTEGER)
snmp_set_error(packet, _("No error-index"));
else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
snmp_set_error(packet, _("error-index uses indefinite length"));
else
{
packet->error_index = asn1_get_integer(&bufptr, bufend, length);
if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_SEQUENCE)
snmp_set_error(packet, _("No variable-bindings SEQUENCE"));
else if (asn1_get_length(&bufptr, bufend) == 0)
snmp_set_error(packet,
_("variable-bindings uses indefinite length"));
else if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_SEQUENCE)
snmp_set_error(packet, _("No VarBind SEQUENCE"));
else if (asn1_get_length(&bufptr, bufend) == 0)
snmp_set_error(packet, _("VarBind uses indefinite length"));
else if (asn1_get_type(&bufptr, bufend) != CUPS_ASN1_OID)
snmp_set_error(packet, _("No name OID"));
else if ((length = asn1_get_length(&bufptr, bufend)) == 0)
snmp_set_error(packet, _("Name OID uses indefinite length"));
else
{
asn1_get_oid(&bufptr, bufend, length, packet->object_name,
CUPS_SNMP_MAX_OID);
packet->object_type = asn1_get_type(&bufptr, bufend);
if ((length = asn1_get_length(&bufptr, bufend)) == 0 &&
packet->object_type != CUPS_ASN1_NULL_VALUE &&
packet->object_type != CUPS_ASN1_OCTET_STRING)
snmp_set_error(packet, _("Value uses indefinite length"));
else
{
switch (packet->object_type)
{
case CUPS_ASN1_BOOLEAN :
packet->object_value.boolean =
asn1_get_integer(&bufptr, bufend, length);
break;
case CUPS_ASN1_INTEGER :
packet->object_value.integer =
asn1_get_integer(&bufptr, bufend, length);
break;
case CUPS_ASN1_NULL_VALUE :
break;
case CUPS_ASN1_OCTET_STRING :
case CUPS_ASN1_BIT_STRING :
case CUPS_ASN1_HEX_STRING :
packet->object_value.string.num_bytes = length;
asn1_get_string(&bufptr, bufend, length,
(char *)packet->object_value.string.bytes,
sizeof(packet->object_value.string.bytes));
break;
case CUPS_ASN1_OID :
asn1_get_oid(&bufptr, bufend, length,
packet->object_value.oid, CUPS_SNMP_MAX_OID);
break;
case CUPS_ASN1_COUNTER :
packet->object_value.counter =
asn1_get_integer(&bufptr, bufend, length);
break;
case CUPS_ASN1_GAUGE :
packet->object_value.gauge =
asn1_get_integer(&bufptr, bufend, length);
break;
case CUPS_ASN1_TIMETICKS :
packet->object_value.timeticks =
asn1_get_integer(&bufptr, bufend, length);
break;
default :
snmp_set_error(packet, _("Unsupported value type"));
break;
}
}
}
}
}
}
}
return (packet->error ? -1 : 0);
}
static int
asn1_encode_snmp(unsigned char *buffer,
size_t bufsize,
cups_snmp_t *packet)
{
unsigned char *bufptr;
int total,
msglen,
commlen,
reqlen,
listlen,
varlen,
namelen,
valuelen;
namelen = asn1_size_oid(packet->object_name);
switch (packet->object_type)
{
case CUPS_ASN1_NULL_VALUE :
valuelen = 0;
break;
case CUPS_ASN1_BOOLEAN :
valuelen = asn1_size_integer(packet->object_value.boolean);
break;
case CUPS_ASN1_INTEGER :
valuelen = asn1_size_integer(packet->object_value.integer);
break;
case CUPS_ASN1_OCTET_STRING :
valuelen = packet->object_value.string.num_bytes;
break;
case CUPS_ASN1_OID :
valuelen = asn1_size_oid(packet->object_value.oid);
break;
default :
packet->error = "Unknown object type";
return (-1);
}
varlen = 1 + asn1_size_length(namelen) + namelen +
1 + asn1_size_length(valuelen) + valuelen;
listlen = 1 + asn1_size_length(varlen) + varlen;
reqlen = 2 + asn1_size_integer(packet->request_id) +
2 + asn1_size_integer(packet->error_status) +
2 + asn1_size_integer(packet->error_index) +
1 + asn1_size_length(listlen) + listlen;
commlen = strlen(packet->community);
msglen = 2 + asn1_size_integer(packet->version) +
1 + asn1_size_length(commlen) + commlen +
1 + asn1_size_length(reqlen) + reqlen;
total = 1 + asn1_size_length(msglen) + msglen;
if (total > (int)bufsize)
{
packet->error = "Message too large for buffer";
return (-1);
}
bufptr = buffer;
*bufptr++ = CUPS_ASN1_SEQUENCE;
asn1_set_length(&bufptr, msglen);
asn1_set_integer(&bufptr, packet->version);
*bufptr++ = CUPS_ASN1_OCTET_STRING;
asn1_set_length(&bufptr, commlen);
memcpy(bufptr, packet->community, commlen);
bufptr += commlen;
*bufptr++ = packet->request_type;
asn1_set_length(&bufptr, reqlen);
asn1_set_integer(&bufptr, packet->request_id);
asn1_set_integer(&bufptr, packet->error_status);
asn1_set_integer(&bufptr, packet->error_index);
*bufptr++ = CUPS_ASN1_SEQUENCE;
asn1_set_length(&bufptr, listlen);
*bufptr++ = CUPS_ASN1_SEQUENCE;
asn1_set_length(&bufptr, varlen);
asn1_set_oid(&bufptr, packet->object_name);
switch (packet->object_type)
{
case CUPS_ASN1_NULL_VALUE :
*bufptr++ = CUPS_ASN1_NULL_VALUE;
*bufptr++ = 0;
break;
case CUPS_ASN1_BOOLEAN :
asn1_set_integer(&bufptr, packet->object_value.boolean);
break;
case CUPS_ASN1_INTEGER :
asn1_set_integer(&bufptr, packet->object_value.integer);
break;
case CUPS_ASN1_OCTET_STRING :
*bufptr++ = CUPS_ASN1_OCTET_STRING;
asn1_set_length(&bufptr, valuelen);
memcpy(bufptr, packet->object_value.string.bytes, valuelen);
bufptr += valuelen;
break;
case CUPS_ASN1_OID :
asn1_set_oid(&bufptr, packet->object_value.oid);
break;
default :
break;
}
return (bufptr - buffer);
}
static int
asn1_get_integer(
unsigned char **buffer,
unsigned char *bufend,
int length)
{
int value;
if (length > sizeof(int))
{
(*buffer) += length;
return (0);
}
for (value = (**buffer & 0x80) ? -1 : 0;
length > 0 && *buffer < bufend;
length --, (*buffer) ++)
value = (value << 8) | **buffer;
return (value);
}
static unsigned
asn1_get_length(unsigned char **buffer,
unsigned char *bufend)
{
unsigned length;
length = **buffer;
(*buffer) ++;
if (length & 128)
{
int count;
if ((count = length & 127) > sizeof(unsigned))
{
(*buffer) += count;
return (0);
}
for (length = 0;
count > 0 && *buffer < bufend;
count --, (*buffer) ++)
length = (length << 8) | **buffer;
}
return (length);
}
static int
asn1_get_oid(
unsigned char **buffer,
unsigned char *bufend,
int length,
int *oid,
int oidsize)
{
unsigned char *valend;
int *oidptr,
*oidend;
int number;
valend = *buffer + length;
oidptr = oid;
oidend = oid + oidsize - 1;
if (valend > bufend)
valend = bufend;
number = asn1_get_packed(buffer, bufend);
if (number < 80)
{
*oidptr++ = number / 40;
number = number % 40;
*oidptr++ = number;
}
else
{
*oidptr++ = 2;
number -= 80;
*oidptr++ = number;
}
while (*buffer < valend)
{
number = asn1_get_packed(buffer, bufend);
if (oidptr < oidend)
*oidptr++ = number;
}
*oidptr = -1;
return (oidptr - oid);
}
static int
asn1_get_packed(
unsigned char **buffer,
unsigned char *bufend)
{
int value;
value = 0;
while ((**buffer & 128) && *buffer < bufend)
{
value = (value << 7) | (**buffer & 127);
(*buffer) ++;
}
if (*buffer < bufend)
{
value = (value << 7) | **buffer;
(*buffer) ++;
}
return (value);
}
static char *
asn1_get_string(
unsigned char **buffer,
unsigned char *bufend,
int length,
char *string,
int strsize)
{
if (length > (bufend - *buffer))
length = bufend - *buffer;
if (length < 0)
{
*string = '\0';
}
else if (length < strsize)
{
if (length > 0)
memcpy(string, *buffer, length);
string[length] = '\0';
}
else
{
memcpy(string, *buffer, strsize - 1);
string[strsize - 1] = '\0';
}
if (length > 0)
(*buffer) += length;
return (length < 0 ? NULL : string);
}
static int
asn1_get_type(unsigned char **buffer,
unsigned char *bufend)
{
int type;
type = **buffer;
(*buffer) ++;
if ((type & 31) == 31)
type = asn1_get_packed(buffer, bufend);
return (type);
}
static void
asn1_set_integer(unsigned char **buffer,
int integer)
{
**buffer = CUPS_ASN1_INTEGER;
(*buffer) ++;
if (integer > 0x7fffff || integer < -0x800000)
{
**buffer = 4;
(*buffer) ++;
**buffer = integer >> 24;
(*buffer) ++;
**buffer = integer >> 16;
(*buffer) ++;
**buffer = integer >> 8;
(*buffer) ++;
**buffer = integer;
(*buffer) ++;
}
else if (integer > 0x7fff || integer < -0x8000)
{
**buffer = 3;
(*buffer) ++;
**buffer = integer >> 16;
(*buffer) ++;
**buffer = integer >> 8;
(*buffer) ++;
**buffer = integer;
(*buffer) ++;
}
else if (integer > 0x7f || integer < -0x80)
{
**buffer = 2;
(*buffer) ++;
**buffer = integer >> 8;
(*buffer) ++;
**buffer = integer;
(*buffer) ++;
}
else
{
**buffer = 1;
(*buffer) ++;
**buffer = integer;
(*buffer) ++;
}
}
static void
asn1_set_length(unsigned char **buffer,
unsigned length)
{
if (length > 255)
{
**buffer = 0x82;
(*buffer) ++;
**buffer = length >> 8;
(*buffer) ++;
**buffer = length;
(*buffer) ++;
}
else if (length > 127)
{
**buffer = 0x81;
(*buffer) ++;
**buffer = length;
(*buffer) ++;
}
else
{
**buffer = length;
(*buffer) ++;
}
}
static void
asn1_set_oid(unsigned char **buffer,
const int *oid)
{
**buffer = CUPS_ASN1_OID;
(*buffer) ++;
asn1_set_length(buffer, asn1_size_oid(oid));
if (oid[1] < 0)
{
asn1_set_packed(buffer, oid[0] * 40);
return;
}
asn1_set_packed(buffer, oid[0] * 40 + oid[1]);
for (oid += 2; *oid >= 0; oid ++)
asn1_set_packed(buffer, *oid);
}
static void
asn1_set_packed(unsigned char **buffer,
int integer)
{
if (integer > 0xfffffff)
{
**buffer = ((integer >> 28) & 0x7f) | 0x80;
(*buffer) ++;
}
if (integer > 0x1fffff)
{
**buffer = ((integer >> 21) & 0x7f) | 0x80;
(*buffer) ++;
}
if (integer > 0x3fff)
{
**buffer = ((integer >> 14) & 0x7f) | 0x80;
(*buffer) ++;
}
if (integer > 0x7f)
{
**buffer = ((integer >> 7) & 0x7f) | 0x80;
(*buffer) ++;
}
**buffer = integer & 0x7f;
(*buffer) ++;
}
static int
asn1_size_integer(int integer)
{
if (integer > 0x7fffff || integer < -0x800000)
return (4);
else if (integer > 0x7fff || integer < -0x8000)
return (3);
else if (integer > 0x7f || integer < -0x80)
return (2);
else
return (1);
}
static int
asn1_size_length(int length)
{
if (length > 0xff)
return (3);
else if (length > 0x7f)
return (2);
else
return (1);
}
static int
asn1_size_oid(const int *oid)
{
int length;
if (oid[1] < 0)
return (asn1_size_packed(oid[0] * 40));
for (length = asn1_size_packed(oid[0] * 40 + oid[1]), oid += 2;
*oid >= 0;
oid ++)
length += asn1_size_packed(*oid);
return (length);
}
static int
asn1_size_packed(int integer)
{
if (integer > 0xfffffff)
return (5);
else if (integer > 0x1fffff)
return (4);
else if (integer > 0x3fff)
return (3);
else if (integer > 0x7f)
return (2);
else
return (1);
}
static void
snmp_set_error(cups_snmp_t *packet,
const char *message)
{
_cups_globals_t *cg = _cupsGlobals();
if (!cg->lang_default)
cg->lang_default = cupsLangDefault();
packet->error = _cupsLangString(cg->lang_default, message);
}