cregit-Linux how code gets into the kernel

Release 4.11 net/irda/parameters.c

Directory: net/irda
/*********************************************************************
 *
 * Filename:      parameters.c
 * Version:       1.0
 * Description:   A more general way to handle (pi,pl,pv) parameters
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Mon Jun  7 10:25:11 1999
 * Modified at:   Sun Jan 30 14:08:39 2000
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 *
 *     Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
 *
 *     This program is free software; you can redistribute it and/or
 *     modify it under the terms of the GNU General Public License as
 *     published by the Free Software Foundation; either version 2 of
 *     the License, or (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program; if not, see <http://www.gnu.org/licenses/>.
 *
 ********************************************************************/

#include <linux/types.h>
#include <linux/module.h>

#include <asm/unaligned.h>
#include <asm/byteorder.h>

#include <net/irda/irda.h>
#include <net/irda/parameters.h>

static int irda_extract_integer(void *self, __u8 *buf, int len, __u8 pi,
				PV_TYPE type, PI_HANDLER func);
static int irda_extract_string(void *self, __u8 *buf, int len, __u8 pi,
			       PV_TYPE type, PI_HANDLER func);
static int irda_extract_octseq(void *self, __u8 *buf, int len, __u8 pi,
			       PV_TYPE type, PI_HANDLER func);
static int irda_extract_no_value(void *self, __u8 *buf, int len, __u8 pi,
				 PV_TYPE type, PI_HANDLER func);

static int irda_insert_integer(void *self, __u8 *buf, int len, __u8 pi,
			       PV_TYPE type, PI_HANDLER func);
static int irda_insert_no_value(void *self, __u8 *buf, int len, __u8 pi,
				PV_TYPE type, PI_HANDLER func);

static int irda_param_unpack(__u8 *buf, char *fmt, ...);

/* Parameter value call table. Must match PV_TYPE */

static const PV_HANDLER pv_extract_table[] = {
	irda_extract_integer, /* Handler for any length integers */
	irda_extract_integer, /* Handler for 8  bits integers */
	irda_extract_integer, /* Handler for 16 bits integers */
	irda_extract_string,  /* Handler for strings */
	irda_extract_integer, /* Handler for 32 bits integers */
	irda_extract_octseq,  /* Handler for octet sequences */
	irda_extract_no_value /* Handler for no value parameters */
};


static const PV_HANDLER pv_insert_table[] = {
	irda_insert_integer, /* Handler for any length integers */
	irda_insert_integer, /* Handler for 8  bits integers */
	irda_insert_integer, /* Handler for 16 bits integers */
	NULL,                /* Handler for strings */
	irda_insert_integer, /* Handler for 32 bits integers */
	NULL,                /* Handler for octet sequences */
	irda_insert_no_value /* Handler for no value parameters */
};

/*
 * Function irda_insert_no_value (self, buf, len, pi, type, func)
 */

static int irda_insert_no_value(void *self, __u8 *buf, int len, __u8 pi, PV_TYPE type, PI_HANDLER func) { irda_param_t p; int ret; p.pi = pi; p.pl = 0; /* Call handler for this parameter */ ret = (*func)(self, &p, PV_GET); /* Extract values anyway, since handler may need them */ irda_param_pack(buf, "bb", p.pi, p.pl); if (ret < 0) return ret; return 2; /* Inserted pl+2 bytes */ }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)89100.00%2100.00%
Total89100.00%2100.00%

/* * Function irda_extract_no_value (self, buf, len, type, func) * * Extracts a parameter without a pv field (pl=0) * */
static int irda_extract_no_value(void *self, __u8 *buf, int len, __u8 pi, PV_TYPE type, PI_HANDLER func) { irda_param_t p; int ret; /* Extract values anyway, since handler may need them */ irda_param_unpack(buf, "bb", &p.pi, &p.pl); /* Call handler for this parameter */ ret = (*func)(self, &p, PV_PUT); if (ret < 0) return ret; return 2; /* Extracted pl+2 bytes */ }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)79100.00%2100.00%
Total79100.00%2100.00%

/* * Function irda_insert_integer (self, buf, len, pi, type, func) */
static int irda_insert_integer(void *self, __u8 *buf, int len, __u8 pi, PV_TYPE type, PI_HANDLER func) { irda_param_t p; int n = 0; int err; p.pi = pi; /* In case handler needs to know */ p.pl = type & PV_MASK; /* The integer type codes the length as well */ p.pv.i = 0; /* Clear value */ /* Call handler for this parameter */ err = (*func)(self, &p, PV_GET); if (err < 0) return err; /* * If parameter length is still 0, then (1) this is an any length * integer, and (2) the handler function does not care which length * we choose to use, so we pick the one the gives the fewest bytes. */ if (p.pl == 0) { if (p.pv.i < 0xff) { pr_debug("%s(), using 1 byte\n", __func__); p.pl = 1; } else if (p.pv.i < 0xffff) { pr_debug("%s(), using 2 bytes\n", __func__); p.pl = 2; } else { pr_debug("%s(), using 4 bytes\n", __func__); p.pl = 4; /* Default length */ } } /* Check if buffer is long enough for insertion */ if (len < (2+p.pl)) { net_warn_ratelimited("%s: buffer too short for insertion!\n", __func__); return -1; } pr_debug("%s(), pi=%#x, pl=%d, pi=%d\n", __func__, p.pi, p.pl, p.pv.i); switch (p.pl) { case 1: n += irda_param_pack(buf, "bbb", p.pi, p.pl, (__u8) p.pv.i); break; case 2: if (type & PV_BIG_ENDIAN) p.pv.i = cpu_to_be16((__u16) p.pv.i); else p.pv.i = cpu_to_le16((__u16) p.pv.i); n += irda_param_pack(buf, "bbs", p.pi, p.pl, (__u16) p.pv.i); break; case 4: if (type & PV_BIG_ENDIAN) cpu_to_be32s(&p.pv.i); else cpu_to_le32s(&p.pv.i); n += irda_param_pack(buf, "bbi", p.pi, p.pl, p.pv.i); break; default: net_warn_ratelimited("%s: length %d not supported\n", __func__, p.pl); /* Skip parameter */ return -1; } return p.pl+2; /* Inserted pl+2 bytes */ }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)34786.10%220.00%
Linus Torvalds307.44%110.00%
Jean Tourrilhes81.99%110.00%
Joe Perches81.99%330.00%
Harvey Harrison61.49%110.00%
Martin Dalecki30.74%110.00%
Guennadi Liakhovetski10.25%110.00%
Total403100.00%10100.00%

/* * Function irda_extract integer (self, buf, len, pi, type, func) * * Extract a possibly variable length integer from buffer, and call * handler for processing of the parameter */
static int irda_extract_integer(void *self, __u8 *buf, int len, __u8 pi, PV_TYPE type, PI_HANDLER func) { irda_param_t p; int n = 0; int extract_len; /* Real length we extract */ int err; p.pi = pi; /* In case handler needs to know */ p.pl = buf[1]; /* Extract length of value */ p.pv.i = 0; /* Clear value */ extract_len = p.pl; /* Default : extract all */ /* Check if buffer is long enough for parsing */ if (len < (2+p.pl)) { net_warn_ratelimited("%s: buffer too short for parsing! Need %d bytes, but len is only %d\n", __func__, p.pl, len); return -1; } /* * Check that the integer length is what we expect it to be. If the * handler want a 16 bits integer then a 32 bits is not good enough * PV_INTEGER means that the handler is flexible. */ if (((type & PV_MASK) != PV_INTEGER) && ((type & PV_MASK) != p.pl)) { net_err_ratelimited("%s: invalid parameter length! Expected %d bytes, but value had %d bytes!\n", __func__, type & PV_MASK, p.pl); /* Most parameters are bit/byte fields or little endian, * so it's ok to only extract a subset of it (the subset * that the handler expect). This is necessary, as some * broken implementations seems to add extra undefined bits. * If the parameter is shorter than we expect or is big * endian, we can't play those tricks. Jean II */ if((p.pl < (type & PV_MASK)) || (type & PV_BIG_ENDIAN)) { /* Skip parameter */ return p.pl+2; } else { /* Extract subset of it, fallthrough */ extract_len = type & PV_MASK; } } switch (extract_len) { case 1: n += irda_param_unpack(buf+2, "b", &p.pv.i); break; case 2: n += irda_param_unpack(buf+2, "s", &p.pv.i); if (type & PV_BIG_ENDIAN) p.pv.i = be16_to_cpu((__u16) p.pv.i); else p.pv.i = le16_to_cpu((__u16) p.pv.i); break; case 4: n += irda_param_unpack(buf+2, "i", &p.pv.i); if (type & PV_BIG_ENDIAN) be32_to_cpus(&p.pv.i); else le32_to_cpus(&p.pv.i); break; default: net_warn_ratelimited("%s: length %d not supported\n", __func__, p.pl); /* Skip parameter */ return p.pl+2; } pr_debug("%s(), pi=%#x, pl=%d, pi=%d\n", __func__, p.pi, p.pl, p.pv.i); /* Call handler for this parameter */ err = (*func)(self, &p, PV_PUT); if (err < 0) return err; return p.pl+2; /* Extracted pl+2 bytes */ }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)30174.32%220.00%
Jean Tourrilhes4711.60%220.00%
Linus Torvalds4110.12%110.00%
Joe Perches81.98%330.00%
Martin Dalecki40.99%110.00%
Harvey Harrison40.99%110.00%
Total405100.00%10100.00%

/* * Function irda_extract_string (self, buf, len, type, func) */
static int irda_extract_string(void *self, __u8 *buf, int len, __u8 pi, PV_TYPE type, PI_HANDLER func) { char str[33]; irda_param_t p; int err; p.pi = pi; /* In case handler needs to know */ p.pl = buf[1]; /* Extract length of value */ if (p.pl > 32) p.pl = 32; pr_debug("%s(), pi=%#x, pl=%d\n", __func__, p.pi, p.pl); /* Check if buffer is long enough for parsing */ if (len < (2+p.pl)) { net_warn_ratelimited("%s: buffer too short for parsing! Need %d bytes, but len is only %d\n", __func__, p.pl, len); return -1; } /* Should be safe to copy string like this since we have already * checked that the buffer is long enough */ strncpy(str, buf+2, p.pl); pr_debug("%s(), str=0x%02x 0x%02x\n", __func__, (__u8)str[0], (__u8)str[1]); /* Null terminate string */ str[p.pl] = '\0'; p.pv.c = str; /* Handler will need to take a copy */ /* Call handler for this parameter */ err = (*func)(self, &p, PV_PUT); if (err < 0) return err; return p.pl+2; /* Extracted pl+2 bytes */ }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)17786.34%222.22%
Samuel Ortiz146.83%111.11%
Joe Perches52.44%333.33%
Jean Tourrilhes41.95%111.11%
Harvey Harrison31.46%111.11%
Martin Dalecki20.98%111.11%
Total205100.00%9100.00%

/* * Function irda_extract_octseq (self, buf, len, type, func) */
static int irda_extract_octseq(void *self, __u8 *buf, int len, __u8 pi, PV_TYPE type, PI_HANDLER func) { irda_param_t p; p.pi = pi; /* In case handler needs to know */ p.pl = buf[1]; /* Extract length of value */ /* Check if buffer is long enough for parsing */ if (len < (2+p.pl)) { net_warn_ratelimited("%s: buffer too short for parsing! Need %d bytes, but len is only %d\n", __func__, p.pl, len); return -1; } pr_debug("%s(), not impl\n", __func__); return p.pl+2; /* Extracted pl+2 bytes */ }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)8490.32%225.00%
Joe Perches44.30%337.50%
Jean Tourrilhes22.15%112.50%
Harvey Harrison22.15%112.50%
Martin Dalecki11.08%112.50%
Total93100.00%8100.00%

/* * Function irda_param_pack (skb, fmt, ...) * * Format: * 'i' = 32 bits integer * 's' = string * */
int irda_param_pack(__u8 *buf, char *fmt, ...) { irda_pv_t arg; va_list args; char *p; int n = 0; va_start(args, fmt); for (p = fmt; *p != '\0'; p++) { switch (*p) { case 'b': /* 8 bits unsigned byte */ buf[n++] = (__u8)va_arg(args, int); break; case 's': /* 16 bits unsigned short */ arg.i = (__u16)va_arg(args, int); put_unaligned((__u16)arg.i, (__u16 *)(buf+n)); n+=2; break; case 'i': /* 32 bits unsigned integer */ arg.i = va_arg(args, __u32); put_unaligned(arg.i, (__u32 *)(buf+n)); n+=4; break; #if 0 case 'c': /* \0 terminated string */ arg.c = va_arg(args, char *); strcpy(buf+n, arg.c); n += strlen(arg.c) + 1; break; #endif default: va_end(args); return -1; } } va_end(args); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)18297.33%375.00%
Linus Torvalds52.67%125.00%
Total187100.00%4100.00%

EXPORT_SYMBOL(irda_param_pack); /* * Function irda_param_unpack (skb, fmt, ...) */
static int irda_param_unpack(__u8 *buf, char *fmt, ...) { irda_pv_t arg; va_list args; char *p; int n = 0; va_start(args, fmt); for (p = fmt; *p != '\0'; p++) { switch (*p) { case 'b': /* 8 bits byte */ arg.ip = va_arg(args, __u32 *); *arg.ip = buf[n++]; break; case 's': /* 16 bits short */ arg.ip = va_arg(args, __u32 *); *arg.ip = get_unaligned((__u16 *)(buf+n)); n+=2; break; case 'i': /* 32 bits unsigned integer */ arg.ip = va_arg(args, __u32 *); *arg.ip = get_unaligned((__u32 *)(buf+n)); n+=4; break; #if 0 case 'c': /* \0 terminated string */ arg.c = va_arg(args, char *); strcpy(arg.c, buf+n); n += strlen(arg.c) + 1; break; #endif default: va_end(args); return -1; } } va_end(args); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)18696.37%250.00%
Linus Torvalds63.11%125.00%
Adrian Bunk10.52%125.00%
Total193100.00%4100.00%

/* * Function irda_param_insert (self, pi, buf, len, info) * * Insert the specified parameter (pi) into buffer. Returns number of * bytes inserted */
int irda_param_insert(void *self, __u8 pi, __u8 *buf, int len, pi_param_info_t *info) { const pi_minor_info_t *pi_minor_info; __u8 pi_minor; __u8 pi_major; int type; int ret = -1; int n = 0; IRDA_ASSERT(buf != NULL, return ret;); IRDA_ASSERT(info != NULL, return ret;); pi_minor = pi & info->pi_mask; pi_major = pi >> info->pi_major_offset; /* Check if the identifier value (pi) is valid */ if ((pi_major > info->len-1) || (pi_minor > info->tables[pi_major].len-1)) { pr_debug("%s(), no handler for parameter=0x%02x\n", __func__, pi); /* Skip this parameter */ return -1; } /* Lookup the info on how to parse this parameter */ pi_minor_info = &info->tables[pi_major].pi_minor_call_table[pi_minor]; /* Find expected data type for this parameter identifier (pi)*/ type = pi_minor_info->type; /* Check if handler has been implemented */ if (!pi_minor_info->func) { net_info_ratelimited("%s: no handler for pi=%#x\n", __func__, pi); /* Skip this parameter */ return -1; } /* Insert parameter value */ ret = (*pv_insert_table[type & PV_MASK])(self, buf+n, len, pi, type, pi_minor_info->func); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)19094.06%111.11%
Jean Tourrilhes41.98%222.22%
Joe Perches31.49%333.33%
Martin Dalecki20.99%111.11%
Harvey Harrison20.99%111.11%
Richard Knutsson10.50%111.11%
Total202100.00%9100.00%

EXPORT_SYMBOL(irda_param_insert); /* * Function irda_param_extract (self, buf, len, info) * * Parse all parameters. If len is correct, then everything should be * safe. Returns the number of bytes that was parsed * */
static int irda_param_extract(void *self, __u8 *buf, int len, pi_param_info_t *info) { const pi_minor_info_t *pi_minor_info; __u8 pi_minor; __u8 pi_major; int type; int ret = -1; int n = 0; IRDA_ASSERT(buf != NULL, return ret;); IRDA_ASSERT(info != NULL, return ret;); pi_minor = buf[n] & info->pi_mask; pi_major = buf[n] >> info->pi_major_offset; /* Check if the identifier value (pi) is valid */ if ((pi_major > info->len-1) || (pi_minor > info->tables[pi_major].len-1)) { pr_debug("%s(), no handler for parameter=0x%02x\n", __func__, buf[0]); /* Skip this parameter */ return 2 + buf[n + 1]; /* Continue */ } /* Lookup the info on how to parse this parameter */ pi_minor_info = &info->tables[pi_major].pi_minor_call_table[pi_minor]; /* Find expected data type for this parameter identifier (pi)*/ type = pi_minor_info->type; pr_debug("%s(), pi=[%d,%d], type=%d\n", __func__, pi_major, pi_minor, type); /* Check if handler has been implemented */ if (!pi_minor_info->func) { net_info_ratelimited("%s: no handler for pi=%#x\n", __func__, buf[n]); /* Skip this parameter */ return 2 + buf[n + 1]; /* Continue */ } /* Parse parameter value */ ret = (*pv_extract_table[type & PV_MASK])(self, buf+n, len, buf[n], type, pi_minor_info->func); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)22592.98%218.18%
Jean Tourrilhes62.48%218.18%
Joe Perches41.65%327.27%
Harvey Harrison31.24%19.09%
Martin Dalecki20.83%19.09%
Adrian Bunk10.41%19.09%
Richard Knutsson10.41%19.09%
Total242100.00%11100.00%

/* * Function irda_param_extract_all (self, buf, len, info) * * Parse all parameters. If len is correct, then everything should be * safe. Returns the number of bytes that was parsed * */
int irda_param_extract_all(void *self, __u8 *buf, int len, pi_param_info_t *info) { int ret = -1; int n = 0; IRDA_ASSERT(buf != NULL, return ret;); IRDA_ASSERT(info != NULL, return ret;); /* * Parse all parameters. Each parameter must be at least two bytes * long or else there is no point in trying to parse it */ while (len > 2) { ret = irda_param_extract(self, buf+n, len, info); if (ret < 0) return ret; n += ret; len -= ret; } return n; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)8696.63%133.33%
Jean Tourrilhes22.25%133.33%
Richard Knutsson11.12%133.33%
Total89100.00%3100.00%

EXPORT_SYMBOL(irda_param_extract_all);

Overall Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)216988.31%522.73%
Linus Torvalds823.34%14.55%
Jean Tourrilhes763.09%418.18%
Joe Perches341.38%418.18%
Harvey Harrison200.81%14.55%
Martin Dalecki200.81%14.55%
Adrian Bunk180.73%14.55%
Stephen Hemminger180.73%14.55%
Samuel Ortiz140.57%14.55%
Richard Knutsson30.12%14.55%
Jeff Kirsher10.04%14.55%
Guennadi Liakhovetski10.04%14.55%
Total2456100.00%22100.00%
Directory: net/irda
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.