Domovská stránka Prehľadávať Pomoc
Prihlásiť sa
SoftwareDesign
/
csu3_am335x
8
0
Fork 0
Súbory Issues 0 Pull requesty 0 Wiki
Branch: master
Branche Tagy
csu3_am335x
/
EVSE
/
GPL
/
open-plc-utils-0.3
/
docbook
/
plcfwd.c.html

plcfwd.c.html 29 KB
Permanentný odkaz História Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137 
  1. <?xml version='1.0' encoding='iso-8859-1'?>
    2. 

  2. <!doctype html public '-//W3C//DTD XHTML 1.0 Strict//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>
    3. 

  3. <html xmlns='http://www.w3c.org/1999/xhtml' lang='en-us'>
    4. 

  4. 	<head>
    5. 

  5. 		<title>
    6. 

  6. 			plcfwd.c
    7. 

  7. 			</title>
    8. 

  8. 		<meta http-equiv='content-type' content='text/html;iso-8859-1'/>
    9. 

  9. 		<meta name='generator' content='motley-tools 1.9.4 13:40:33 Feb 18 2015'/>
    10. 

  10. 		<meta name='author' content='cmaier@cmassoc.net'/>
    11. 

  11. 		<meta name='robots' content='noindex,nofollow'/>
    12. 

  12. 		<link href='toolkit.css' rel='stylesheet' type='text/css'/>
    13. 

  13. 		</head>
    14. 

  14. 	<body>
    15. 

  15. 		<div class='headerlink'>
    16. 

  16. 			[<a href='plcdevs.c.html' title=' plcdevs.c '>PREV</a>]
    17. 

  17. 			[<a href='toolkit.html' title=' Index '>HOME</a>]
    18. 

  18. 			[<a href='plcget.c.html' title=' plcget.c '>NEXT</a>]
    19. 

  19. 			</div>
    20. 

  20. <pre>
    21. 

  21. /*====================================================================*
    22. 

  22.  *
    23. 

  23.  *   Copyright (c) 2013 Qualcomm Atheros, Inc.
    24. 

  24.  *
    25. 

  25.  *   All rights reserved.
    26. 

  26.  *
    27. 

  27.  *   Redistribution and use in source and binary forms, with or 
    28. 

  28.  *   without modification, are permitted (subject to the limitations 
    29. 

  29.  *   in the disclaimer below) provided that the following conditions 
    30. 

  30.  *   are met:
    31. 

  31.  *
    32. 

  32.  *   * Redistributions of source code must retain the above copyright 
    33. 

  33.  *     notice, this list of conditions and the following disclaimer.
    34. 

  34.  *
    35. 

  35.  *   * Redistributions in binary form must reproduce the above 
    36. 

  36.  *     copyright notice, this list of conditions and the following 
    37. 

  37.  *     disclaimer in the documentation and/or other materials 
    38. 

  38.  *     provided with the distribution.
    39. 

  39.  *
    40. 

  40.  *   * Neither the name of Qualcomm Atheros nor the names of 
    41. 

  41.  *     its contributors may be used to endorse or promote products 
    42. 

  42.  *     derived from this software without specific prior written 
    43. 

  43.  *     permission.
    44. 

  44.  *
    45. 

  45.  *   NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE 
    46. 

  46.  *   GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE 
    47. 

  47.  *   COPYRIGHT HOLDERS AND CONTRIBUTORS &quot;AS IS&quot; AND ANY EXPRESS OR 
    48. 

  48.  *   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
    49. 

  49.  *   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
    50. 

  50.  *   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
    51. 

  51.  *   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
    52. 

  52.  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
    53. 

  53.  *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
    54. 

  54.  *   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
    55. 

  55.  *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
    56. 

  56.  *   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
    57. 

  57.  *   OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
    58. 

  58.  *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
    59. 

  59.  *
    60. 

  60.  *--------------------------------------------------------------------*/
    61. 

  61. 

  62. /*====================================================================*
    63. 

  63.  *
    64. 

  64.  *   plcfwd.c - Atheros PLC Forward Configuration Manager;
    65. 

  65.  *
    66. 

  66.  *
    67. 

  67.  *--------------------------------------------------------------------*/
    68. 

  68. 

  69. /*====================================================================*&quot;
    70. 

  70.  *   system header files;
    71. 

  71.  *--------------------------------------------------------------------*/
    72. 

  72. 

  73. #include &lt;unistd.h&gt;
    74. 

  74. #include &lt;stdlib.h&gt;
    75. 

  75. #include &lt;stdint.h&gt;
    76. 

  76. #include &lt;limits.h&gt;
    77. 

  77. #include &lt;ctype.h&gt;
    78. 

  78. 

  79. /*====================================================================*
    80. 

  80.  *   custom header files;
    81. 

  81.  *--------------------------------------------------------------------*/
    82. 

  82. 

  83. #include &quot;../tools/getoptv.h&quot;
    84. 

  84. #include &quot;../tools/putoptv.h&quot;
    85. 

  85. #include &quot;../tools/memory.h&quot;
    86. 

  86. #include &quot;../tools/number.h&quot;
    87. 

  87. #include &quot;../tools/symbol.h&quot;
    88. 

  88. #include &quot;../tools/types.h&quot;
    89. 

  89. #include &quot;../tools/flags.h&quot;
    90. 

  90. #include &quot;../tools/files.h&quot;
    91. 

  91. #include &quot;../tools/error.h&quot;
    92. 

  92. #include &quot;../plc/plc.h&quot;
    93. 

  93. 

  94. /*====================================================================*
    95. 

  95.  *   custom source files;
    96. 

  96.  *--------------------------------------------------------------------*/
    97. 

  97. 

  98. #ifndef MAKEFILE
    99. 

  99. #include &quot;../plc/Confirm.c&quot;
    100. 

  100. #include &quot;../plc/Display.c&quot;
    101. 

  101. #include &quot;../plc/Failure.c&quot;
    102. 

  102. #include &quot;../plc/Request.c&quot;
    103. 

  103. #include &quot;../plc/ReadMME.c&quot;
    104. 

  104. #include &quot;../plc/SendMME.c&quot;
    105. 

  105. #include &quot;../plc/Devices.c&quot;
    106. 

  106. #endif
    107. 

  107. 

  108. #ifndef MAKEFILE
    109. 

  109. #include &quot;../tools/getoptv.c&quot;
    110. 

  110. #include &quot;../tools/putoptv.c&quot;
    111. 

  111. #include &quot;../tools/version.c&quot;
    112. 

  112. #include &quot;../tools/uintspec.c&quot;
    113. 

  113. #include &quot;../tools/basespec.c&quot;
    114. 

  114. #include &quot;../tools/hexdump.c&quot;
    115. 

  115. #include &quot;../tools/hexview.c&quot;
    116. 

  116. #include &quot;../tools/hexencode.c&quot;
    117. 

  117. #include &quot;../tools/hexdecode.c&quot;
    118. 

  118. #include &quot;../tools/hexout.c&quot;
    119. 

  119. #include &quot;../tools/todigit.c&quot;
    120. 

  120. #include &quot;../tools/synonym.c&quot;
    121. 

  121. #include &quot;../tools/binout.c&quot;
    122. 

  122. #include &quot;../tools/error.c&quot;
    123. 

  123. #endif
    124. 

  124. 

  125. #ifndef MAKEFILE
    126. 

  126. #include &quot;../ether/openchannel.c&quot;
    127. 

  127. #include &quot;../ether/closechannel.c&quot;
    128. 

  128. #include &quot;../ether/readpacket.c&quot;
    129. 

  129. #include &quot;../ether/sendpacket.c&quot;
    130. 

  130. #include &quot;../ether/channel.c&quot;
    131. 

  131. #endif
    132. 

  132. 

  133. #ifndef MAKEFILE
    134. 

  134. #include &quot;../mme/MMECode.c&quot;
    135. 

  135. #include &quot;../mme/EthernetHeader.c&quot;
    136. 

  136. #include &quot;../mme/QualcommHeader.c&quot;
    137. 

  137. #include &quot;../mme/UnwantedMessage.c&quot;
    138. 

  138. #endif
    139. 

  139. 

  140. /*====================================================================*
    141. 

  141.  *   program constants;
    142. 

  142.  *--------------------------------------------------------------------*/
    143. 

  143. 

  144. #define PLCFWD_VERBOSE (1 &lt;&lt; 0)
    145. 

  145. #define PLCFWD_SILENCE (1 &lt;&lt; 1)
    146. 

  146. 

  147. #define PLCFWD_LENGTH 0
    148. 

  148. #define PLCFWD_OFFSET 0
    149. 

  149. 

  150. #define PLCFWD_GET 0
    151. 

  151. #define PLCFWD_ADD 1
    152. 

  152. #define PLCFWD_REM 2
    153. 

  153. #define PLCFWD_STO 3
    154. 

  154. #define PLCFWD_CTL 4
    155. 

  155. #define PLCFWD_SET 5
    156. 

  156. #define PLCFWD_FWD 6
    157. 

  157. #define PLCFWD_VER 0
    158. 

  158. 

  159. /*====================================================================*
    160. 

  160.  *   program variables;
    161. 

  161.  *--------------------------------------------------------------------*/
    162. 

  162. 

  163. /*
    164. 

  164.  *   this structure is only used in the VS_FORWARD_CONFIG message but
    165. 

  165.  *   it is common to several variations of the message and is used in
    166. 

  166.  *   arrays;
    167. 

  167.  */
    168. 

  168. 

  169. #ifndef __GNUC__
    170. 

  170. #pragma pack (push,1)
    171. 

  171. #endif
    172. 

  172. 

  173. typedef struct item
    174. 

  174. 

  175. {
    176. 

  176. 	uint8_t MAC_ADDR [ETHER_ADDR_LEN];
    177. 

  177. 	uint16_t NUM_VLANIDS;
    178. 

  178. 	uint16_t VLANID [10];
    179. 

  179. }
    180. 

  180. 

  181. item;
    182. 

  182. 

  183. #ifndef __GNUC__
    184. 

  184. #pragma pack (pop)
    185. 

  185. #endif
    186. 

  186. 

  187. /*
    188. 

  188.  *   synonym table for options -M and -S;
    189. 

  189.  */
    190. 

  190. 

  191. #define STATES (sizeof (states) / sizeof (struct _term_))
    192. 

  192. 

  193. static const struct _term_ states [] =
    194. 

  194. 

  195. {
    196. 

  196. 	{
    197. 

  197. 		&quot;disable&quot;,
    198. 

  198. 		&quot;0&quot;
    199. 

  199. 	},
    200. 

  200. 	{
    201. 

  201. 		&quot;enable&quot;,
    202. 

  202. 		&quot;1&quot;
    203. 

  203. 	},
    204. 

  204. 	{
    205. 

  205. 		&quot;off&quot;,
    206. 

  206. 		&quot;0&quot;
    207. 

  207. 	},
    208. 

  208. 	{
    209. 

  209. 		&quot;on&quot;,
    210. 

  210. 		&quot;1&quot;
    211. 

  211. 	}
    212. 

  212. };
    213. 

  213. 

  214. /*====================================================================*
    215. 

  215.  *
    216. 

  216.  *   void readitem (struct item * item, char const * string);
    217. 

  217.  *
    218. 

  218.  *   encode a slave structure with infomation specified by a string
    219. 

  219.  *   specification has the following production:
    220. 

  220.  *
    221. 

  221.  *   &lt;spec&gt; := &lt;mac_addr&gt;
    222. 

  222.  *   &lt;spec&gt; := &lt;spec&gt;,&lt;vlan_id&gt;
    223. 

  223.  *
    224. 

  224.  *   basically, encode slave-&gt;MAC_ADDR then encode slave-&gt;VLANID[]
    225. 

  225.  *   with hexadecimal VLANID values; we allow 10 VLANID values but
    226. 

  226.  *   only 8 are legal;
    227. 

  227.  *
    228. 

  228.  *   the idea is to read multiple input strings and call this function
    229. 

  229.  *   to initialize one or more slave structures; it is possible to fit
    230. 

  230.  *   up to 128 slave structures in one message frame;
    231. 

  231.  *
    232. 

  232.  *
    233. 

  233.  *--------------------------------------------------------------------*/
    234. 

  234. 

  235. static void readitem (struct item * item, char const * string)
    236. 

  236. 

  237. {
    238. 

  238. 	register uint8_t * origin = (uint8_t *)(item-&gt;MAC_ADDR);
    239. 

  239. 	register uint8_t * offset = (uint8_t *)(item-&gt;MAC_ADDR);
    240. 

  240. 	size_t extent = sizeof (item-&gt;MAC_ADDR);
    241. 

  241. 	memset (item, 0, sizeof (* item));
    242. 

  242. 	while ((extent) &amp;&amp; (*string))
    243. 

  243. 	{
    244. 

  244. 		unsigned radix = RADIX_HEX;
    245. 

  245. 		unsigned field = sizeof (uint8_t) + sizeof (uint8_t);
    246. 

  246. 		unsigned value = 0;
    247. 

  247. 		unsigned digit = 0;
    248. 

  248. 		if ((offset != origin) &amp;&amp; (*string == HEX_EXTENDER))
    249. 

  249. 		{
    250. 

  250. 			string++;
    251. 

  251. 		}
    252. 

  252. 		while (field--)
    253. 

  253. 		{
    254. 

  254. 			if ((digit = todigit (*string)) &lt; radix)
    255. 

  255. 			{
    256. 

  256. 				value *= radix;
    257. 

  257. 				value += digit;
    258. 

  258. 				string++;
    259. 

  259. 				continue;
    260. 

  260. 			}
    261. 

  261. 			error (1, EINVAL, &quot;bad MAC address: ...[%s] (1)&quot;, string);
    262. 

  262. 		}
    263. 

  263. 		*offset = value;
    264. 

  264. 		offset++;
    265. 

  265. 		extent--;
    266. 

  266. 	}
    267. 

  267. 	if (extent)
    268. 

  268. 	{
    269. 

  269. 		error (1, EINVAL, &quot;bad MAC address: ...[%s] (2)&quot;, string);
    270. 

  270. 	}
    271. 

  271. 	while (isspace (*string))
    272. 

  272. 	{
    273. 

  273. 		string++;
    274. 

  274. 	}
    275. 

  275. 	if ((*string) &amp;&amp; (*string != ','))
    276. 

  276. 	{
    277. 

  277. 		error (1, EINVAL, &quot;bad MAC address: ...[%s] (3)&quot;, string);
    278. 

  278. 	}
    279. 

  279. 	while (*string == ',')
    280. 

  280. 	{
    281. 

  281. 		unsigned radix = RADIX_DEC;
    282. 

  282. 		unsigned digit = 0;
    283. 

  283. 		unsigned value = 0;
    284. 

  284. 		do
    285. 

  285. 		{
    286. 

  286. 			string++;
    287. 

  287. 		}
    288. 

  288. 		while (isspace (*string));
    289. 

  289. 		while ((digit = todigit (*string)) &lt; radix)
    290. 

  290. 		{
    291. 

  291. 			value *= radix;
    292. 

  292. 			value += digit;
    293. 

  293. 			string++;
    294. 

  294. 		}
    295. 

  295. 		while (isspace (*string))
    296. 

  296. 		{
    297. 

  297. 			string++;
    298. 

  298. 		}
    299. 

  299. 		if (item-&gt;NUM_VLANIDS &lt; (sizeof (item-&gt;VLANID) / sizeof (uint16_t)))
    300. 

  300. 		{
    301. 

  301. 			item-&gt;VLANID [item-&gt;NUM_VLANIDS++] = value;
    302. 

  302. 		}
    303. 

  303. 	}
    304. 

  304. 	while (isspace (*string))
    305. 

  305. 	{
    306. 

  306. 		string++;
    307. 

  307. 	}
    308. 

  308. 	if (*string)
    309. 

  309. 	{
    310. 

  310. 		error (1, EINVAL, &quot;bad VLAN ID: ...[%s]&quot;, string);
    311. 

  311. 	}
    312. 

  312. 	return;
    313. 

  313. }
    314. 

  314. 

  315. /*====================================================================*
    316. 

  316.  *
    317. 

  317.  *   unsigned readlist (struct item list [], unsigned size);
    318. 

  318.  *
    319. 

  319.  *   read one or more items from stdin; discard comments; assume one
    320. 

  320.  *   item per line; permit multiple items on one line when separated
    321. 

  321.  *   by semicolon; items cannot straddle lines; readitem () controls
    322. 

  322.  *   what consitutes one item;
    323. 

  323.  *
    324. 

  324.  *--------------------------------------------------------------------*/
    325. 

  325. 

  326. static unsigned readlist (struct item list [], unsigned size)
    327. 

  327. 

  328. {
    329. 

  329. 	struct item * item = list;
    330. 

  330. 	char string [1024];
    331. 

  331. 	char * sp = string;
    332. 

  332. 	signed c;
    333. 

  333. 	for (c = getc (stdin); c != EOF; c = getc (stdin))
    334. 

  334. 	{
    335. 

  335. 		if (isspace (c))
    336. 

  336. 		{
    337. 

  337. 			continue;
    338. 

  338. 		}
    339. 

  339. 		if (c == '#')
    340. 

  340. 		{
    341. 

  341. 			while ((c != '\n') &amp;&amp; (c != EOF))
    342. 

  342. 			{
    343. 

  343. 				c = getc (stdin);
    344. 

  344. 			}
    345. 

  345. 			continue;
    346. 

  346. 		}
    347. 

  347. 		sp = string;
    348. 

  348. 		while ((c != ';') &amp;&amp; (c != '\n') &amp;&amp; (c != EOF))
    349. 

  349. 		{
    350. 

  350. 			*sp++ = (char)(c);
    351. 

  351. 			c = getc (stdin);
    352. 

  352. 		}
    353. 

  353. 		*sp = (char)(0);
    354. 

  354. 		if (size)
    355. 

  355. 		{
    356. 

  356. 			readitem (item++, string);
    357. 

  357. 			size--;
    358. 

  358. 		}
    359. 

  359. 	}
    360. 

  360. 	return ((unsigned)(item - list));
    361. 

  361. }
    362. 

  362. 

  363. /*====================================================================*
    364. 

  364.  *
    365. 

  365.  *   void showlist (struct item list [], unsigned items)
    366. 

  366.  *
    367. 

  367.  *   print item list on stdout in a format suitable for input using
    368. 

  368.  *   readlist (); this function may be commented out if it not used;
    369. 

  369.  *
    370. 

  370.  *
    371. 

  371.  *--------------------------------------------------------------------*/
    372. 

  372. 

  373. #if 0
    374. 

  374. 

  375. static void showlist (struct item list [], unsigned items)
    376. 

  376. 

  377. {
    378. 

  378. 	while (items--)
    379. 

  379. 	{
    380. 

  380. 		uint16_t fields = list-&gt;NUM_VLANIDS;
    381. 

  381. 		uint16_t * field = list-&gt;VLANID;
    382. 

  382. 		hexout (list-&gt;MAC_ADDR, sizeof (list-&gt;MAC_ADDR), 0, 0, stdout);
    383. 

  383. 		while (fields--)
    384. 

  384. 		{
    385. 

  385. 			printf (&quot;, %d&quot;, *field);
    386. 

  386. 			field++;
    387. 

  387. 		}
    388. 

  388. 		printf (&quot;\n&quot;);
    389. 

  389. 		list++;
    390. 

  390. 	}
    391. 

  391. 	return;
    392. 

  392. }
    393. 

  393. 

  394. #endif
    395. 

  395. 

  396. /*====================================================================*
    397. 

  397.  *
    398. 

  398.  *   signed ReadVLANIDs (struct plc * plc, uint32_t offset, uint32_t length);
    399. 

  399.  *
    400. 

  400.  *
    401. 

  401.  *--------------------------------------------------------------------*/
    402. 

  402. 

  403. static signed ReadVLANIDs (struct plc * plc, uint32_t offset, uint32_t length)
    404. 

  404. 

  405. {
    406. 

  406. 	struct channel * channel = (struct channel *)(plc-&gt;channel);
    407. 

  407. 	struct message * message = (struct message *)(plc-&gt;message);
    408. 

  408. 

  409. #ifndef __GNUC__
    410. 

  410. #pragma pack (push,1)
    411. 

  411. #endif
    412. 

  412. 

  413. 	struct __packed vs_forward_config_request
    414. 

  414. 	{
    415. 

  415. 		struct ethernet_hdr ethernet;
    416. 

  416. 		struct qualcomm_hdr qualcomm;
    417. 

  417. 		uint8_t RESERVED1;
    418. 

  418. 		uint8_t MREQUEST;
    419. 

  419. 		uint8_t MVERSION;
    420. 

  420. 		uint32_t RESERVED2;
    421. 

  421. 		uint32_t DATA_LENGTH;
    422. 

  422. 		uint32_t DATA_OFFSET;
    423. 

  423. 		uint16_t RESERVED3;
    424. 

  424. 	}
    425. 

  425. 	* request = (struct vs_forward_config_request *) (message);
    426. 

  426. 	struct __packed vs_forward_config_confirm
    427. 

  427. 	{
    428. 

  428. 		struct ethernet_hdr ethernet;
    429. 

  429. 		struct qualcomm_hdr qualcomm;
    430. 

  430. 		uint8_t RESERVED1;
    431. 

  431. 		uint8_t RESULTCODE;
    432. 

  432. 		uint8_t OPERATION;
    433. 

  433. 		uint8_t MVERSION;
    434. 

  434. 		uint32_t RESERVED2;
    435. 

  435. 		uint32_t DATA_LENGTH;
    436. 

  436. 		uint32_t DATA_OFFSET;
    437. 

  437. 		uint8_t DATA [PLC_MODULE_SIZE];
    438. 

  438. 	}
    439. 

  439. 	* confirm = (struct vs_forward_config_confirm *) (message);
    440. 

  440. 

  441. #ifndef __GNUC__
    442. 

  442. #pragma pack (pop)
    443. 

  443. #endif
    444. 

  444. 

  445. 	memset (message, 0, sizeof (* message));
    446. 

  446. 	EthernetHeader (&amp;request-&gt;ethernet, channel-&gt;peer, channel-&gt;host, channel-&gt;type);
    447. 

  447. 	QualcommHeader (&amp;request-&gt;qualcomm, 0, (VS_FORWARD_CONFIG | MMTYPE_REQ));
    448. 

  448. 	request-&gt;MREQUEST = PLCFWD_GET;
    449. 

  449. 	request-&gt;MVERSION = PLCFWD_VER;
    450. 

  450. 	request-&gt;DATA_OFFSET = HTOLE32 (offset);
    451. 

  451. 	request-&gt;DATA_LENGTH = HTOLE32 (length);
    452. 

  452. 	plc-&gt;packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
    453. 

  453. 	if (SendMME (plc) &lt;= 0)
    454. 

  454. 	{
    455. 

  455. 		error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
    456. 

  456. 		return (-1);
    457. 

  457. 	}
    458. 

  458. 	while (ReadMME (plc, 0, (VS_FORWARD_CONFIG | MMTYPE_CNF)) &gt; 0)
    459. 

  459. 	{
    460. 

  460. 		if (confirm-&gt;RESULTCODE)
    461. 

  461. 		{
    462. 

  462. 			Failure (plc, PLC_WONTDOIT);
    463. 

  463. 			continue;
    464. 

  464. 		}
    465. 

  465. 		hexview (confirm-&gt;DATA, LE32TOH (confirm-&gt;DATA_OFFSET), LE32TOH (confirm-&gt;DATA_LENGTH), stdout);
    466. 

  466. 	}
    467. 

  467. 	return (0);
    468. 

  468. }
    469. 

  469. 

  470. /*====================================================================*
    471. 

  471.  *
    472. 

  472.  *   signed AddVLANIDs (struct plc * plc, struct item list [], unsigned items);
    473. 

  473.  *
    474. 

  474.  *
    475. 

  475.  *--------------------------------------------------------------------*/
    476. 

  476. 

  477. static signed AddVLANIDs (struct plc * plc, struct item list [], unsigned items)
    478. 

  478. 

  479. {
    480. 

  480. 	struct channel * channel = (struct channel *)(plc-&gt;channel);
    481. 

  481. 	struct message * message = (struct message *)(plc-&gt;message);
    482. 

  482. 

  483. #ifndef __GNUC__
    484. 

  484. #pragma pack (push,1)
    485. 

  485. #endif
    486. 

  486. 

  487. 	struct __packed vs_forward_config_request
    488. 

  488. 	{
    489. 

  489. 		struct ethernet_hdr ethernet;
    490. 

  490. 		struct qualcomm_hdr qualcomm;
    491. 

  491. 		uint8_t RESERVED1;
    492. 

  492. 		uint8_t MREQUEST;
    493. 

  493. 		uint8_t MVERSION;
    494. 

  494. 		uint32_t RESERVED2;
    495. 

  495. 		uint16_t ITEMS;
    496. 

  496. 		struct item LIST [1];
    497. 

  497. 	}
    498. 

  498. 	* request = (struct vs_forward_config_request *) (message);
    499. 

  499. 	struct __packed vs_forward_config_confirm
    500. 

  500. 	{
    501. 

  501. 		struct ethernet_hdr ethernet;
    502. 

  502. 		struct qualcomm_hdr qualcomm;
    503. 

  503. 		uint8_t RESERVED1;
    504. 

  504. 		uint8_t RESULTCODE;
    505. 

  505. 		uint8_t OPERATION;
    506. 

  506. 		uint8_t MVERSION;
    507. 

  507. 		uint32_t RESERVED2;
    508. 

  508. 	}
    509. 

  509. 	* confirm = (struct vs_forward_config_confirm *) (message);
    510. 

  510. 

  511. #ifndef __GNUC__
    512. 

  512. #pragma pack (pop)
    513. 

  513. #endif
    514. 

  514. 

  515. 	struct item * item = request-&gt;LIST;
    516. 

  516. 	memset (message, 0, sizeof (* message));
    517. 

  517. 	EthernetHeader (&amp;request-&gt;ethernet, channel-&gt;peer, channel-&gt;host, channel-&gt;type);
    518. 

  518. 	QualcommHeader (&amp;request-&gt;qualcomm, 0, (VS_FORWARD_CONFIG | MMTYPE_REQ));
    519. 

  519. 	request-&gt;MREQUEST = PLCFWD_ADD;
    520. 

  520. 	request-&gt;MVERSION = PLCFWD_VER;
    521. 

  521. 	request-&gt;ITEMS = HTOLE16 (items);
    522. 

  522. 	while (items--)
    523. 

  523. 	{
    524. 

  524. 		unsigned count;
    525. 

  525. 		memcpy (item-&gt;MAC_ADDR, list-&gt;MAC_ADDR, sizeof (item-&gt;MAC_ADDR));
    526. 

  526. 		item-&gt;NUM_VLANIDS = HTOLE16 (list-&gt;NUM_VLANIDS);
    527. 

  527. 		for (count = 0; count &lt; list-&gt;NUM_VLANIDS; count++)
    528. 

  528. 		{
    529. 

  529. 			item-&gt;VLANID [count] = HTOLE16 (list-&gt;VLANID [count]);
    530. 

  530. 		}
    531. 

  531. 

  532. // item++;
    533. 

  533. 

  534. 		item = (struct item *)(&amp;item-&gt;VLANID [count]);
    535. 

  535. 		list++;
    536. 

  536. 	}
    537. 

  537. 	plc-&gt;packetsize = (signed)((uint8_t *)(item) - (uint8_t *)(request));
    538. 

  538. 	if (SendMME (plc) &lt;= 0)
    539. 

  539. 	{
    540. 

  540. 		error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
    541. 

  541. 		return (-1);
    542. 

  542. 	}
    543. 

  543. 	while (ReadMME (plc, 0, (VS_FORWARD_CONFIG | MMTYPE_CNF)) &gt; 0)
    544. 

  544. 	{
    545. 

  545. 		if (confirm-&gt;RESULTCODE)
    546. 

  546. 		{
    547. 

  547. 			Failure (plc, PLC_WONTDOIT);
    548. 

  548. 			continue;
    549. 

  549. 		}
    550. 

  550. 	}
    551. 

  551. 	return (0);
    552. 

  552. }
    553. 

  553. 

  554. /*====================================================================*
    555. 

  555.  *
    556. 

  556.  *   signed RemoveVLANIDs (struct plc * plc, struct item list [], unsigned items);
    557. 

  557.  *
    558. 

  558.  *
    559. 

  559.  *--------------------------------------------------------------------*/
    560. 

  560. 

  561. static signed RemoveVLANIDs (struct plc * plc, struct item list [], unsigned items)
    562. 

  562. 

  563. {
    564. 

  564. 	struct channel * channel = (struct channel *)(plc-&gt;channel);
    565. 

  565. 	struct message * message = (struct message *)(plc-&gt;message);
    566. 

  566. 

  567. #ifndef __GNUC__
    568. 

  568. #pragma pack (push,1)
    569. 

  569. #endif
    570. 

  570. 

  571. 	struct __packed vs_forward_config_request
    572. 

  572. 	{
    573. 

  573. 		struct ethernet_hdr ethernet;
    574. 

  574. 		struct qualcomm_hdr qualcomm;
    575. 

  575. 		uint8_t RESERVED1;
    576. 

  576. 		uint8_t MREQUEST;
    577. 

  577. 		uint8_t MVERSION;
    578. 

  578. 		uint32_t RESERVED2;
    579. 

  579. 		uint16_t ITEMS;
    580. 

  580. 		struct item LIST [1];
    581. 

  581. 	}
    582. 

  582. 	* request = (struct vs_forward_config_request *) (message);
    583. 

  583. 	struct __packed vs_forward_config_confirm
    584. 

  584. 	{
    585. 

  585. 		struct ethernet_hdr ethernet;
    586. 

  586. 		struct qualcomm_hdr qualcomm;
    587. 

  587. 		uint8_t RESERVED1;
    588. 

  588. 		uint8_t RESULTCODE;
    589. 

  589. 		uint8_t OPERATION;
    590. 

  590. 		uint8_t MVERSION;
    591. 

  591. 		uint32_t RESERVED2;
    592. 

  592. 	}
    593. 

  593. 	* confirm = (struct vs_forward_config_confirm *) (message);
    594. 

  594. 

  595. #ifndef __GNUC__
    596. 

  596. #pragma pack (pop)
    597. 

  597. #endif
    598. 

  598. 

  599. 	struct item * item = request-&gt;LIST;
    600. 

  600. 	memset (message, 0, sizeof (* message));
    601. 

  601. 	EthernetHeader (&amp;request-&gt;ethernet, channel-&gt;peer, channel-&gt;host, channel-&gt;type);
    602. 

  602. 	QualcommHeader (&amp;request-&gt;qualcomm, 0, (VS_FORWARD_CONFIG | MMTYPE_REQ));
    603. 

  603. 	request-&gt;MREQUEST = PLCFWD_REM;
    604. 

  604. 	request-&gt;MVERSION = PLCFWD_VER;
    605. 

  605. 	request-&gt;ITEMS = HTOLE16 (items);
    606. 

  606. 	while (items--)
    607. 

  607. 	{
    608. 

  608. 		unsigned count;
    609. 

  609. 		memcpy (item-&gt;MAC_ADDR, list-&gt;MAC_ADDR, sizeof (item-&gt;MAC_ADDR));
    610. 

  610. 		item-&gt;NUM_VLANIDS = HTOLE16 (list-&gt;NUM_VLANIDS);
    611. 

  611. 		for (count = 0; count &lt; list-&gt;NUM_VLANIDS; count++)
    612. 

  612. 		{
    613. 

  613. 			item-&gt;VLANID [count] = HTOLE16 (list-&gt;VLANID [count]);
    614. 

  614. 		}
    615. 

  615. 

  616. // item++;
    617. 

  617. 

  618. 		item = (struct item *)(&amp;item-&gt;VLANID [count]);
    619. 

  619. 		list++;
    620. 

  620. 	}
    621. 

  621. 	plc-&gt;packetsize = (signed)((uint8_t *)(item) - (uint8_t *)(request));
    622. 

  622. 	if (SendMME (plc) &lt;= 0)
    623. 

  623. 	{
    624. 

  624. 		error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
    625. 

  625. 		return (-1);
    626. 

  626. 	}
    627. 

  627. 	while (ReadMME (plc, 0, (VS_FORWARD_CONFIG | MMTYPE_CNF)) &gt; 0)
    628. 

  628. 	{
    629. 

  629. 		if (confirm-&gt;RESULTCODE)
    630. 

  630. 		{
    631. 

  631. 			Failure (plc, PLC_WONTDOIT);
    632. 

  632. 			continue;
    633. 

  633. 		}
    634. 

  634. 	}
    635. 

  635. 	return (0);
    636. 

  636. }
    637. 

  637. 

  638. /*====================================================================*
    639. 

  639.  *
    640. 

  640.  *   signed CommitVLANIDs (struct plc * plc);
    641. 

  641.  *
    642. 

  642.  *
    643. 

  643.  *--------------------------------------------------------------------*/
    644. 

  644. 

  645. static signed CommitVLANIDs (struct plc * plc)
    646. 

  646. 

  647. {
    648. 

  648. 	struct channel * channel = (struct channel *)(plc-&gt;channel);
    649. 

  649. 	struct message * message = (struct message *)(plc-&gt;message);
    650. 

  650. 

  651. #ifndef __GNUC__
    652. 

  652. #pragma pack (push,1)
    653. 

  653. #endif
    654. 

  654. 

  655. 	struct __packed vs_forward_config_request
    656. 

  656. 	{
    657. 

  657. 		struct ethernet_hdr ethernet;
    658. 

  658. 		struct qualcomm_hdr qualcomm;
    659. 

  659. 		uint8_t RESERVED1;
    660. 

  660. 		uint8_t MREQUEST;
    661. 

  661. 		uint8_t MVERSION;
    662. 

  662. 		uint32_t RESERVED2;
    663. 

  663. 	}
    664. 

  664. 	* request = (struct vs_forward_config_request *) (message);
    665. 

  665. 	struct __packed vs_forward_config_confirm
    666. 

  666. 	{
    667. 

  667. 		struct ethernet_hdr ethernet;
    668. 

  668. 		struct qualcomm_hdr qualcomm;
    669. 

  669. 		uint8_t RESERVED1;
    670. 

  670. 		uint8_t RESULTCODE;
    671. 

  671. 		uint8_t OPERATION;
    672. 

  672. 		uint8_t MVERSION;
    673. 

  673. 		uint32_t RESERVED2;
    674. 

  674. 	}
    675. 

  675. 	* confirm = (struct vs_forward_config_confirm *) (message);
    676. 

  676. 

  677. #ifndef __GNUC__
    678. 

  678. #pragma pack (pop)
    679. 

  679. #endif
    680. 

  680. 

  681. 	memset (message, 0, sizeof (* message));
    682. 

  682. 	EthernetHeader (&amp;request-&gt;ethernet, channel-&gt;peer, channel-&gt;host, channel-&gt;type);
    683. 

  683. 	QualcommHeader (&amp;request-&gt;qualcomm, 0, (VS_FORWARD_CONFIG | MMTYPE_REQ));
    684. 

  684. 	request-&gt;MREQUEST = PLCFWD_STO;
    685. 

  685. 	request-&gt;MVERSION = PLCFWD_VER;
    686. 

  686. 	plc-&gt;packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
    687. 

  687. 	if (SendMME (plc) &lt;= 0)
    688. 

  688. 	{
    689. 

  689. 		error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
    690. 

  690. 		return (-1);
    691. 

  691. 	}
    692. 

  692. 	while (ReadMME (plc, 0, (VS_FORWARD_CONFIG | MMTYPE_CNF)) &gt; 0)
    693. 

  693. 	{
    694. 

  694. 		if (confirm-&gt;RESULTCODE)
    695. 

  695. 		{
    696. 

  696. 			Failure (plc, PLC_WONTDOIT);
    697. 

  697. 			continue;
    698. 

  698. 		}
    699. 

  699. 	}
    700. 

  700. 	return (0);
    701. 

  701. }
    702. 

  702. 

  703. /*====================================================================*
    704. 

  704.  *
    705. 

  705.  *   signed ControlVLANIDs (struct plc * plc);
    706. 

  706.  *
    707. 

  707.  *
    708. 

  708.  *--------------------------------------------------------------------*/
    709. 

  709. 

  710. static signed ControlVLANIDs (struct plc * plc)
    711. 

  711. 

  712. {
    713. 

  713. 	struct channel * channel = (struct channel *)(plc-&gt;channel);
    714. 

  714. 	struct message * message = (struct message *)(plc-&gt;message);
    715. 

  715. 

  716. #ifndef __GNUC__
    717. 

  717. #pragma pack (push,1)
    718. 

  718. #endif
    719. 

  719. 

  720. 	struct __packed vs_forward_config_request
    721. 

  721. 	{
    722. 

  722. 		struct ethernet_hdr ethernet;
    723. 

  723. 		struct qualcomm_hdr qualcomm;
    724. 

  724. 		uint8_t RESERVED1;
    725. 

  725. 		uint8_t MREQUEST;
    726. 

  726. 		uint8_t MVERSION;
    727. 

  727. 		uint32_t RESERVED2;
    728. 

  728. 		uint8_t ENABLE;
    729. 

  729. 		uint8_t UPSTREAMCHECK;
    730. 

  730. 		uint8_t RESERVED3;
    731. 

  731. 	}
    732. 

  732. 	* request = (struct vs_forward_config_request *) (message);
    733. 

  733. 	struct __packed vs_forward_config_confirm
    734. 

  734. 	{
    735. 

  735. 		struct ethernet_hdr ethernet;
    736. 

  736. 		struct qualcomm_hdr qualcomm;
    737. 

  737. 		uint8_t RESERVED1;
    738. 

  738. 		uint8_t RESULTCODE;
    739. 

  739. 		uint8_t OPERATION;
    740. 

  740. 		uint8_t MVERSION;
    741. 

  741. 		uint32_t RESERVED2;
    742. 

  742. 	}
    743. 

  743. 	* confirm = (struct vs_forward_config_confirm *) (message);
    744. 

  744. 

  745. #ifndef __GNUC__
    746. 

  746. #pragma pack (pop)
    747. 

  747. #endif
    748. 

  748. 

  749. 	memset (message, 0, sizeof (* message));
    750. 

  750. 	EthernetHeader (&amp;request-&gt;ethernet, channel-&gt;peer, channel-&gt;host, channel-&gt;type);
    751. 

  751. 	QualcommHeader (&amp;request-&gt;qualcomm, 0, (VS_FORWARD_CONFIG | MMTYPE_REQ));
    752. 

  752. 	request-&gt;MREQUEST = PLCFWD_CTL;
    753. 

  753. 	request-&gt;MVERSION = PLCFWD_VER;
    754. 

  754. 	request-&gt;ENABLE = plc-&gt;module;
    755. 

  755. 	request-&gt;UPSTREAMCHECK = plc-&gt;pushbutton;
    756. 

  756. 	plc-&gt;packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
    757. 

  757. 	if (SendMME (plc) &lt;= 0)
    758. 

  758. 	{
    759. 

  759. 		error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
    760. 

  760. 		return (-1);
    761. 

  761. 	}
    762. 

  762. 	while (ReadMME (plc, 0, (VS_FORWARD_CONFIG | MMTYPE_CNF)) &gt; 0)
    763. 

  763. 	{
    764. 

  764. 		if (confirm-&gt;RESULTCODE)
    765. 

  765. 		{
    766. 

  766. 			Failure (plc, PLC_WONTDOIT);
    767. 

  767. 			continue;
    768. 

  768. 		}
    769. 

  769. 	}
    770. 

  770. 	return (0);
    771. 

  771. }
    772. 

  772. 

  773. /*====================================================================*
    774. 

  774.  *
    775. 

  775.  *   signed DefaultVLANIDs (struct plc * plc);
    776. 

  776.  *
    777. 

  777.  *
    778. 

  778.  *--------------------------------------------------------------------*/
    779. 

  779. 

  780. static signed DefaultVLANIDs (struct plc * plc, struct item list [], unsigned items)
    781. 

  781. 

  782. {
    783. 

  783. 	struct channel * channel = (struct channel *)(plc-&gt;channel);
    784. 

  784. 	struct message * message = (struct message *)(plc-&gt;message);
    785. 

  785. 

  786. #ifndef __GNUC__
    787. 

  787. #pragma pack (push,1)
    788. 

  788. #endif
    789. 

  789. 

  790. 	struct __packed vs_forward_config_request
    791. 

  791. 	{
    792. 

  792. 		struct ethernet_hdr ethernet;
    793. 

  793. 		struct qualcomm_hdr qualcomm;
    794. 

  794. 		uint8_t RESERVED1;
    795. 

  795. 		uint8_t MREQUEST;
    796. 

  796. 		uint8_t MVERSION;
    797. 

  797. 		uint32_t RESERVED2;
    798. 

  798. 		uint16_t VLANID;
    799. 

  799. 		uint16_t RESERVED3;
    800. 

  800. 	}
    801. 

  801. 	* request = (struct vs_forward_config_request *) (message);
    802. 

  802. 	struct __packed vs_forward_config_confirm
    803. 

  803. 	{
    804. 

  804. 		struct ethernet_hdr ethernet;
    805. 

  805. 		struct qualcomm_hdr qualcomm;
    806. 

  806. 		uint8_t RESERVED1;
    807. 

  807. 		uint8_t RESULTCODE;
    808. 

  808. 		uint8_t OPERATION;
    809. 

  809. 		uint8_t MVERSION;
    810. 

  810. 		uint32_t RESERVED2;
    811. 

  811. 	}
    812. 

  812. 	* confirm = (struct vs_forward_config_confirm *) (message);
    813. 

  813. 

  814. #ifndef __GNUC__
    815. 

  815. #pragma pack (pop)
    816. 

  816. #endif
    817. 

  817. 

  818. 	memset (message, 0, sizeof (* message));
    819. 

  819. 	EthernetHeader (&amp;request-&gt;ethernet, channel-&gt;peer, channel-&gt;host, channel-&gt;type);
    820. 

  820. 	QualcommHeader (&amp;request-&gt;qualcomm, 0, (VS_FORWARD_CONFIG | MMTYPE_REQ));
    821. 

  821. 	request-&gt;MREQUEST = PLCFWD_SET;
    822. 

  822. 	request-&gt;MVERSION = PLCFWD_VER;
    823. 

  823. 	request-&gt;VLANID = HTOLE16 (list [0].VLANID [0]);
    824. 

  824. 	plc-&gt;packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
    825. 

  825. 	if (SendMME (plc) &lt;= 0)
    826. 

  826. 	{
    827. 

  827. 		error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
    828. 

  828. 		return (-1);
    829. 

  829. 	}
    830. 

  830. 	while (ReadMME (plc, 0, (VS_FORWARD_CONFIG | MMTYPE_CNF)) &gt; 0)
    831. 

  831. 	{
    832. 

  832. 		if (confirm-&gt;RESULTCODE)
    833. 

  833. 		{
    834. 

  834. 			Failure (plc, PLC_WONTDOIT);
    835. 

  835. 			continue;
    836. 

  836. 		}
    837. 

  837. 	}
    838. 

  838. 	return (0);
    839. 

  839. }
    840. 

  840. 

  841. /*====================================================================*
    842. 

  842.  *
    843. 

  843.  *   signed ForwardVLANIDs (struct plc * plc);
    844. 

  844.  *
    845. 

  845.  *
    846. 

  846.  *--------------------------------------------------------------------*/
    847. 

  847. 

  848. static signed ForwardVLANIDs (struct plc * plc)
    849. 

  849. 

  850. {
    851. 

  851. 	struct channel * channel = (struct channel *)(plc-&gt;channel);
    852. 

  852. 	struct message * message = (struct message *)(plc-&gt;message);
    853. 

  853. 

  854. #ifndef __GNUC__
    855. 

  855. #pragma pack (push,1)
    856. 

  856. #endif
    857. 

  857. 

  858. 	struct __packed vs_forward_config_request
    859. 

  859. 	{
    860. 

  860. 		struct ethernet_hdr ethernet;
    861. 

  861. 		struct qualcomm_hdr qualcomm;
    862. 

  862. 		uint8_t RESERVED1;
    863. 

  863. 		uint8_t MREQUEST;
    864. 

  864. 		uint8_t MVERSION;
    865. 

  865. 		uint32_t RESERVED2;
    866. 

  866. 		uint8_t ENABLED;
    867. 

  867. 		uint16_t VLANID;
    868. 

  868. 		uint16_t RESERVED3;
    869. 

  869. 		struct item ITEM;
    870. 

  870. 	}
    871. 

  871. 	* request = (struct vs_forward_config_request *) (message);
    872. 

  872. 	struct __packed vs_forward_config_confirm
    873. 

  873. 	{
    874. 

  874. 		struct ethernet_hdr ethernet;
    875. 

  875. 		struct qualcomm_hdr qualcomm;
    876. 

  876. 		uint8_t RESERVED1;
    877. 

  877. 		uint8_t RESULTCODE;
    878. 

  878. 		uint8_t OPERATION;
    879. 

  879. 		uint8_t MVERSION;
    880. 

  880. 		uint32_t RESERVED2;
    881. 

  881. 	}
    882. 

  882. 	* confirm = (struct vs_forward_config_confirm *) (message);
    883. 

  883. 

  884. #ifndef __GNUC__
    885. 

  885. #pragma pack (pop)
    886. 

  886. #endif
    887. 

  887. 

  888. 	memset (message, 0, sizeof (* message));
    889. 

  889. 	EthernetHeader (&amp;request-&gt;ethernet, channel-&gt;peer, channel-&gt;host, channel-&gt;type);
    890. 

  890. 	QualcommHeader (&amp;request-&gt;qualcomm, 0, (VS_FORWARD_CONFIG | MMTYPE_REQ));
    891. 

  891. 	request-&gt;MREQUEST = PLCFWD_FWD;
    892. 

  892. 	request-&gt;MVERSION = PLCFWD_VER;
    893. 

  893. 	plc-&gt;packetsize = (ETHER_MIN_LEN - ETHER_CRC_LEN);
    894. 

  894. 	if (SendMME (plc) &lt;= 0)
    895. 

  895. 	{
    896. 

  896. 		error (PLC_EXIT (plc), errno, CHANNEL_CANTSEND);
    897. 

  897. 		return (-1);
    898. 

  898. 	}
    899. 

  899. 	while (ReadMME (plc, 0, (VS_FORWARD_CONFIG | MMTYPE_CNF)) &gt; 0)
    900. 

  900. 	{
    901. 

  901. 		if (confirm-&gt;RESULTCODE)
    902. 

  902. 		{
    903. 

  903. 			Failure (plc, PLC_WONTDOIT);
    904. 

  904. 			continue;
    905. 

  905. 		}
    906. 

  906. 	}
    907. 

  907. 	return (0);
    908. 

  908. }
    909. 

  909. 

  910. /*====================================================================*
    911. 

  911.  *
    912. 

  912.  *   void function (struct plc * plc, struct item list [], unsigned items);
    913. 

  913.  *
    914. 

  914.  *   perform the VLANID action specified by the action member
    915. 

  915.  *   in struct plc as set in the main program; only one action
    916. 

  916.  *   is performed;
    917. 

  917.  *
    918. 

  918.  *
    919. 

  919.  *--------------------------------------------------------------------*/
    920. 

  920. 

  921. static void function (struct plc * plc, uint32_t offset, uint32_t length, struct item * list, unsigned items)
    922. 

  922. 

  923. {
    924. 

  924. 	if (plc-&gt;action == PLCFWD_GET)
    925. 

  925. 	{
    926. 

  926. 		ReadVLANIDs (plc, offset, length);
    927. 

  927. 		return;
    928. 

  928. 	}
    929. 

  929. 	if (plc-&gt;action == PLCFWD_ADD)
    930. 

  930. 	{
    931. 

  931. 		AddVLANIDs (plc, list, items);
    932. 

  932. 		return;
    933. 

  933. 	}
    934. 

  934. 	if (plc-&gt;action == PLCFWD_REM)
    935. 

  935. 	{
    936. 

  936. 		RemoveVLANIDs (plc, list, items);
    937. 

  937. 		return;
    938. 

  938. 	}
    939. 

  939. 	if (plc-&gt;action == PLCFWD_STO)
    940. 

  940. 	{
    941. 

  941. 		CommitVLANIDs (plc);
    942. 

  942. 		return;
    943. 

  943. 	}
    944. 

  944. 	if (plc-&gt;action == PLCFWD_CTL)
    945. 

  945. 	{
    946. 

  946. 		ControlVLANIDs (plc);
    947. 

  947. 		return;
    948. 

  948. 	}
    949. 

  949. 	if (plc-&gt;action == PLCFWD_SET)
    950. 

  950. 	{
    951. 

  951. 		DefaultVLANIDs (plc, list, items);
    952. 

  952. 		return;
    953. 

  953. 	}
    954. 

  954. 	if (plc-&gt;action == PLCFWD_FWD)
    955. 

  955. 	{
    956. 

  956. 		ForwardVLANIDs (plc);
    957. 

  957. 		return;
    958. 

  958. 	}
    959. 

  959. 	return;
    960. 

  960. }
    961. 

  961. 

  962. /*====================================================================*
    963. 

  963.  *
    964. 

  964.  *   int main (int argc, char const * argv[]);
    965. 

  965.  *
    966. 

  966.  *
    967. 

  967.  *--------------------------------------------------------------------*/
    968. 

  968. 

  969. int main (int argc, char const * argv [])
    970. 

  970. 

  971. {
    972. 

  972. 	extern struct channel channel;
    973. 

  973. 	static char const * optv [] =
    974. 

  974. 	{
    975. 

  975. 		&quot;ACD:ef:i:l:M:o:qRS:t:vxz:&quot;,
    976. 

  976. 		&quot;device [device] [...] [&gt; stdout]&quot;,
    977. 

  977. 		&quot;Qualcomm Atheros VLANID Forward Configuration Manager&quot;,
    978. 

  978. 		&quot;A\tadd VLAN ID of multiple slaves to memory&quot;,
    979. 

  979. 		&quot;C\tcommit configuration to flash memory&quot;,
    980. 

  980. 		&quot;D x\tset default VLAN ID&quot;,
    981. 

  981. 		&quot;e\tredirect stderr to stdout&quot;,
    982. 

  982. 		&quot;f s\tread VLANIDS from file (s)&quot;,
    983. 

  983. 

  984. #if defined (WINPCAP) || defined (LIBPCAP)
    985. 

  985. 

  986. 		&quot;i n\thost interface is (n) [&quot; LITERAL (CHANNEL_ETHNUMBER) &quot;]&quot;,
    987. 

  987. 

  988. #else
    989. 

  989. 

  990. 		&quot;i s\thost interface is (s) [&quot; LITERAL (CHANNEL_ETHDEVICE) &quot;]&quot;,
    991. 

  991. 

  992. #endif
    993. 

  993. 

  994. 		&quot;l n\tdata length in bytes [&quot; LITERAL (PLCFWD_LENGTH) &quot;]&quot;,
    995. 

  995. 		&quot;M n\tenable VLANID forwarding on the master&quot;,
    996. 

  996. 		&quot;o x\tdata offset in bytes [&quot; LITERAL (PLCFWD_OFFSET) &quot;]&quot;,
    997. 

  997. 		&quot;q\tquiet mode&quot;,
    998. 

  998. 		&quot;R\tremove VLAN ID of multiple slaves from memory&quot;,
    999. 

  999. 		&quot;S n\tenable VLANID forwarding on all slaves&quot;,
    1000. 

  1000. 		&quot;t n\ttimeout is (n) millisecond [&quot; LITERAL (CHANNEL_TIMEOUT) &quot;]&quot;,
    1001. 

  1001. 		&quot;v\tverbose mode&quot;,
    1002. 

  1002. 		&quot;x\texit on error&quot;,
    1003. 

  1003. 		&quot;z s\tslavespec&quot;,
    1004. 

  1004. 		(char const *) (0)
    1005. 

  1005. 	};
    1006. 

  1006. 

  1007. #include &quot;../plc/plc.c&quot;
    1008. 

  1008. 

  1009. 	struct item list [128];
    1010. 

  1010. 	unsigned size = sizeof (list) / sizeof (struct item);
    1011. 

  1011. 	unsigned items = 0;
    1012. 

  1012. 	uint32_t offset = 0;
    1013. 

  1013. 	uint32_t length = 0;
    1014. 

  1014. 	signed c;
    1015. 

  1015. 	memset (&amp;list, 0, sizeof (list));
    1016. 

  1016. 	if (getenv (PLCDEVICE))
    1017. 

  1017. 	{
    1018. 

  1018. 		channel.ifname = strdup (getenv (PLCDEVICE));
    1019. 

  1019. 	}
    1020. 

  1020. 	optind = 1;
    1021. 

  1021. 	while ((c = getoptv (argc, argv, optv)) != -1)
    1022. 

  1022. 	{
    1023. 

  1023. 		switch (c)
    1024. 

  1024. 		{
    1025. 

  1025. 		case 'A':
    1026. 

  1026. 			plc.action = PLCFWD_ADD;
    1027. 

  1027. 			break;
    1028. 

  1028. 		case 'C':
    1029. 

  1029. 			plc.action = PLCFWD_STO;
    1030. 

  1030. 			break;
    1031. 

  1031. 		case 'D':
    1032. 

  1032. 			plc.action = PLCFWD_SET;
    1033. 

  1033. 			list [0].VLANID [0] = (uint16_t)(basespec (optarg, 10, sizeof (uint16_t)));
    1034. 

  1034. 			break;
    1035. 

  1035. 		case 'e':
    1036. 

  1036. 			dup2 (STDOUT_FILENO, STDERR_FILENO);
    1037. 

  1037. 			break;
    1038. 

  1038. 		case 'f':
    1039. 

  1039. 			if (!freopen (optarg, &quot;rb&quot;, stdin))
    1040. 

  1040. 			{
    1041. 

  1041. 				error (1, errno, &quot;%s&quot;, optarg);
    1042. 

  1042. 			}
    1043. 

  1043. 			items += readlist (&amp;list [items], size - items);
    1044. 

  1044. 			break;
    1045. 

  1045. 		case 'i':
    1046. 

  1046. 

  1047. #if defined (WINPCAP) || defined (LIBPCAP)
    1048. 

  1048. 

  1049. 			channel.ifindex = atoi (optarg);
    1050. 

  1050. 

  1051. #else
    1052. 

  1052. 

  1053. 			channel.ifname = optarg;
    1054. 

  1054. 

  1055. #endif
    1056. 

  1056. 

  1057. 			break;
    1058. 

  1058. 		case 'M':
    1059. 

  1059. 			plc.action = PLCFWD_CTL;
    1060. 

  1060. 			plc.module = (uint8_t)(uintspec (synonym (optarg, states, STATES), 0, UCHAR_MAX));
    1061. 

  1061. 			break;
    1062. 

  1062. 		case 'l':
    1063. 

  1063. 			length = (uint32_t) (basespec (optarg, 10, sizeof (length)));
    1064. 

  1064. 			break;
    1065. 

  1065. 		case 'o':
    1066. 

  1066. 			offset = (uint32_t) (basespec (optarg, 10, sizeof (offset)));
    1067. 

  1067. 			break;
    1068. 

  1068. 		case 'q':
    1069. 

  1069. 			_setbits (channel.flags, CHANNEL_SILENCE);
    1070. 

  1070. 			_setbits (plc.flags, PLC_SILENCE);
    1071. 

  1071. 			break;
    1072. 

  1072. 		case 'R':
    1073. 

  1073. 			plc.action = PLCFWD_REM;
    1074. 

  1074. 			break;
    1075. 

  1075. 		case 'S':
    1076. 

  1076. 			plc.action = PLCFWD_CTL;
    1077. 

  1077. 			plc.pushbutton = (uint8_t)(uintspec (synonym (optarg, states, STATES), 0, UCHAR_MAX));
    1078. 

  1078. 			break;
    1079. 

  1079. 		case 't':
    1080. 

  1080. 			channel.timeout = (signed)(uintspec (optarg, 0, UINT_MAX));
    1081. 

  1081. 			break;
    1082. 

  1082. 		case 'v':
    1083. 

  1083. 			_setbits (channel.flags, CHANNEL_VERBOSE);
    1084. 

  1084. 			_setbits (plc.flags, PLC_VERBOSE);
    1085. 

  1085. 			break;
    1086. 

  1086. 		case 'x':
    1087. 

  1087. 			_setbits (plc.flags, PLC_BAILOUT);
    1088. 

  1088. 			break;
    1089. 

  1089. 		case 'z':
    1090. 

  1090. 			readitem (&amp;list [items++], optarg);
    1091. 

  1091. 			break;
    1092. 

  1092. 		default:
    1093. 

  1093. 			break;
    1094. 

  1094. 		}
    1095. 

  1095. 	}
    1096. 

  1096. 	argc -= optind;
    1097. 

  1097. 	argv += optind;
    1098. 

  1098. 

  1099. #if 0
    1100. 

  1100. 

  1101. 	showlist (list, items);
    1102. 

  1102. 

  1103. #endif
    1104. 

  1104. 

  1105. 	openchannel (&amp;channel);
    1106. 

  1106. 	if (!(plc.message = malloc (sizeof (* plc.message))))
    1107. 

  1107. 	{
    1108. 

  1108. 		error (1, errno, PLC_NOMEMORY);
    1109. 

  1109. 	}
    1110. 

  1110. 	if (!argc)
    1111. 

  1111. 	{
    1112. 

  1112. 		function (&amp;plc, offset, length, list, items);
    1113. 

  1113. 	}
    1114. 

  1114. 	while ((argc) &amp;&amp; (* argv))
    1115. 

  1115. 	{
    1116. 

  1116. 		if (!hexencode (channel.peer, sizeof (channel.peer), synonym (* argv, devices, SIZEOF (devices))))
    1117. 

  1117. 		{
    1118. 

  1118. 			error (1, errno, PLC_BAD_MAC, * argv);
    1119. 

  1119. 		}
    1120. 

  1120. 		function (&amp;plc, offset, length, list, items);
    1121. 

  1121. 		argv++;
    1122. 

  1122. 		argc--;
    1123. 

  1123. 	}
    1124. 

  1124. 	free (plc.message);
    1125. 

  1125. 	closechannel (&amp;channel);
    1126. 

  1126. 	return (0);
    1127. 

  1127. }
    1128. 

  1128. 

  1129. 

  1130. </pre>
    1131. 

  1131. 		<div class='footerlink'>
    1132. 

  1132. 			[<a href='plcdevs.c.html' title=' plcdevs.c '>PREV</a>]
    1133. 

  1133. 			[<a href='toolkit.html' title=' Index '>HOME</a>]
    1134. 

  1134. 			[<a href='plcget.c.html' title=' plcget.c '>NEXT</a>]
    1135. 

  1135. 			</div>
    1136. 

  1136. 		</body>
    1137. 

  1137. 	</html>
    1138.