Release 4.8 net/irda/parameters.c

/*********************************************************************
 *
 * 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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
89
100.00%
2
100.00%
Total
89
100.00%
2
100.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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
79
100.00%
2
100.00%
Total
79
100.00%
2
100.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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
347
86.10%
2
20.00%
linus torvalds
linus torvalds
30
7.44%
1
10.00%
jean tourrilhes
jean tourrilhes
8
1.99%
1
10.00%
joe perches
joe perches
8
1.99%
3
30.00%
harvey harrison
harvey harrison
6
1.49%
1
10.00%
martin dalecki
martin dalecki
3
0.74%
1
10.00%
guennadi liakhovetski
guennadi liakhovetski
1
0.25%
1
10.00%
Total
403
100.00%
10
100.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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
301
74.32%
2
20.00%
jean tourrilhes
jean tourrilhes
47
11.60%
2
20.00%
linus torvalds
linus torvalds
41
10.12%
1
10.00%
joe perches
joe perches
8
1.98%
3
30.00%
harvey harrison
harvey harrison
4
0.99%
1
10.00%
martin dalecki
martin dalecki
4
0.99%
1
10.00%
Total
405
100.00%
10
100.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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
177
86.34%
2
22.22%
samuel ortiz
samuel ortiz
14
6.83%
1
11.11%
joe perches
joe perches
5
2.44%
3
33.33%
jean tourrilhes
jean tourrilhes
4
1.95%
1
11.11%
harvey harrison
harvey harrison
3
1.46%
1
11.11%
martin dalecki
martin dalecki
2
0.98%
1
11.11%
Total
205
100.00%
9
100.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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
84
90.32%
2
25.00%
joe perches
joe perches
4
4.30%
3
37.50%
harvey harrison
harvey harrison
2
2.15%
1
12.50%
jean tourrilhes
jean tourrilhes
2
2.15%
1
12.50%
martin dalecki
martin dalecki
1
1.08%
1
12.50%
Total
93
100.00%
8
100.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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
182
97.33%
3
75.00%
linus torvalds
linus torvalds
5
2.67%
1
25.00%
Total
187
100.00%
4
100.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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
186
96.37%
2
50.00%
linus torvalds
linus torvalds
6
3.11%
1
25.00%
adrian bunk
adrian bunk
1
0.52%
1
25.00%
Total
193
100.00%
4
100.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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
190
94.06%
1
11.11%
jean tourrilhes
jean tourrilhes
4
1.98%
2
22.22%
joe perches
joe perches
3
1.49%
3
33.33%
harvey harrison
harvey harrison
2
0.99%
1
11.11%
martin dalecki
martin dalecki
2
0.99%
1
11.11%
richard knutsson
richard knutsson
1
0.50%
1
11.11%
Total
202
100.00%
9
100.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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
225
92.98%
2
18.18%
jean tourrilhes
jean tourrilhes
6
2.48%
2
18.18%
joe perches
joe perches
4
1.65%
3
27.27%
harvey harrison
harvey harrison
3
1.24%
1
9.09%
martin dalecki
martin dalecki
2
0.83%
1
9.09%
richard knutsson
richard knutsson
1
0.41%
1
9.09%
adrian bunk
adrian bunk
1
0.41%
1
9.09%
Total
242
100.00%
11
100.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
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
86
96.63%
1
33.33%
jean tourrilhes
jean tourrilhes
2
2.25%
1
33.33%
richard knutsson
richard knutsson
1
1.12%
1
33.33%
Total
89
100.00%
3
100.00%


EXPORT_SYMBOL(irda_param_extract_all);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
2169
88.31%
5
22.73%
linus torvalds
linus torvalds
82
3.34%
1
4.55%
jean tourrilhes
jean tourrilhes
76
3.09%
4
18.18%
joe perches
joe perches
34
1.38%
4
18.18%
martin dalecki
martin dalecki
20
0.81%
1
4.55%
harvey harrison
harvey harrison
20
0.81%
1
4.55%
adrian bunk
adrian bunk
18
0.73%
1
4.55%
stephen hemminger
stephen hemminger
18
0.73%
1
4.55%
samuel ortiz
samuel ortiz
14
0.57%
1
4.55%
richard knutsson
richard knutsson
3
0.12%
1
4.55%
guennadi liakhovetski
guennadi liakhovetski
1
0.04%
1
4.55%
jeff kirsher
jeff kirsher
1
0.04%
1
4.55%
Total
2456
100.00%
22
100.00%
  
Directory: net/irda

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.