Context Navigation

source: uKadecot/trunk/kadecot/wamp_dealer.c@ 125

Last change on this file since 125 was 125, checked in by coas-nagasima, 9 years ago
ECHONET Lite規格に準拠していない動作を修正。 WebSocketの接続先URLを/webapi.ashxから/webapiに変更。 DHCPのリトライ処理が行われていなかったのを修正。 DHCPの有効/無効設定を追加し、固定IPアドレスを設定できるよう変更。
Property svn:eol-style set to `native` Property svn:keywords set to `Id` Property svn:mime-type set to `text/x-chdr; charset=SHIFT_JIS`
File size: 55.6 KB

Line
1	/*
2	* TOPPERS ECHONET Lite Communication Middleware
3	*
4	* Copyright (C) 2015 Cores Co., Ltd. Japan
5	*
6	* 上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
7	* ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
8	* 変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
9	* (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
10	* 権表示，この利用条件および下記の無保証規定が，そのままの形でソー
11	* スコード中に含まれていること．
12	* (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
13	* 用できる形で再配布する場合には，再配布に伴うドキュメント（利用
14	* 者マニュアルなど）に，上記の著作権表示，この利用条件および下記
15	* の無保証規定を掲載すること．
16	* (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
17	* 用できない形で再配布する場合には，次のいずれかの条件を満たすこ
18	* と．
19	* (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
20	* 作権表示，この利用条件および下記の無保証規定を掲載すること．
21	* (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
22	* 報告すること．
23	* (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
24	* 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
25	* また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
26	* 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
27	* 免責すること．
28	*
29	* 本ソフトウェアは，無保証で提供されているものである．上記著作権者お
30	* よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
31	* に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
32	* アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
33	* の責任を負わない．
34	*
35	* @(#) $Id: wamp_dealer.c 125 2015-07-23 06:21:02Z coas-nagasima $
36	*/
37
38	#include <string.h>
39	#include "wamp.h"
40	#include "wamp_dealer.h"
41	#include "main.h"
42	#include "fbs_string.h"
43	#include "kadecot_names.h"
44	#include "kernel_cfg.h"
45	#include "echonet_agent.h"
46	#include "arduino.h"
47	#include "data_flash.h"
48	#include "uip.h"
49	#include "uip_adpt.h"
50
51	#ifndef _MSC_VER
52	#ifndef strcpy_s
53	#define strcpy_s(s1, s1m, s2) strcpy(s1, s2)
54	#endif
55
56	#ifndef strncpy_s
57	#define strncpy_s(dst, dsz, src, sz) strncpy(dst, src, sz)
58	#endif
59
60	size_t strnlen(const char *s, size_t maxlen);
61	#endif
62
63	static void wamp_dealer_call_dummy_param(wamp_dealer_t *dealer,
64	jsonsl_action_t action, struct jsonsl_state_st state, const char buf);
65	static void wamp_dealer_call_kadecot_param(wamp_dealer_t *dealer,
66	jsonsl_action_t action, struct jsonsl_state_st state, const char buf);
67	static void wamp_dealer_call_ecnl_param(wamp_dealer_t *dealer,
68	jsonsl_action_t action, struct jsonsl_state_st state, const char buf);
69	static void wamp_dealer_call_arduino_param(wamp_dealer_t *dealer,
70	jsonsl_action_t action, struct jsonsl_state_st state, const char buf);
71	static void wamp_dealer_call_init_params_param(wamp_dealer_t *dealer,
72	jsonsl_action_t action, struct jsonsl_state_st state, const char buf);
73
74	static void wamp_dealer_none_close(struct wamp_dealer *dealer);
75	static void wamp_dealer_get_devicelist_close(struct wamp_dealer *dealer);
76	static void wamp_dealer_kadecot_get_close(struct wamp_dealer *dealer);
77	static void wamp_dealer_kadecot_set_close(struct wamp_dealer *dealer);
78	static void wamp_dealer_get_deviceinfo_close(struct wamp_dealer *dealer);
79	static void wamp_dealer_ecnl_set_close(struct wamp_dealer *dealer);
80	static void wamp_dealer_ecnl_get_close(struct wamp_dealer *dealer);
81	static void wamp_dealer_ecnl_setget_close(struct wamp_dealer *dealer);
82	static void wamp_dealer_pin_mode_close(struct wamp_dealer *dealer);
83	static void wamp_dealer_digital_write_close(struct wamp_dealer *dealer);
84	static void wamp_dealer_digital_read_close(struct wamp_dealer *dealer);
85	static void wamp_dealer_analog_read_close(struct wamp_dealer *dealer);
86	static void wamp_dealer_analog_write_close(struct wamp_dealer *dealer);
87	static void wamp_dealer_set_init_params_close(struct wamp_dealer *dealer);
88	static void wamp_dealer_get_init_params_close(struct wamp_dealer *dealer);
89
90	static echonetlite_device_t wamp_dealer_get_device(wamp_dealer_t dealer, int deviceId);
91
92	static bool_t wamp_dealer_get_epc(const char *propName, int nameLen,
93	uint16_t devType, uint8_t epc, uint8_t pdc);
94	static void wamp_dealer_get_devicelist(struct wamp_dealer *dealer);
95
96	int wamp_stob(const char str, uint8_t dst, int dstc);
97
98	void wamp_dealer_register(wamp_dealer_t *dealer)
99	{
100	}
101
102	void wamp_dealer_register_request_id(wamp_dealer_t dealer, const char value)
103	{
104	}
105
106	void wamp_dealer_register_options(wamp_dealer_t dealer, const char value)
107	{
108	}
109
110	void wamp_dealer_register_options_param(wamp_dealer_t *dealer, jsonsl_action_t action,
111	struct jsonsl_state_st state, const char buf)
112	{
113	}
114
115	void wamp_dealer_register_procedure(wamp_dealer_t dealer, const char value)
116	{
117	}
118
119	void wamp_dealer_register_close(struct wamp_state *s)
120	{
121	}
122
123	void wamp_dealer_unregister(wamp_dealer_t *dealer)
124	{
125	}
126
127	void wamp_dealer_unregister_request_id(wamp_dealer_t dealer, const char value)
128	{
129	}
130
131	void wamp_dealer_unregister_registration_id(wamp_dealer_t dealer, const char value)
132	{
133	}
134
135	void wamp_dealer_unregister_close(struct wamp_state *s)
136	{
137	}
138
139	void wamp_dealer_call(wamp_dealer_t *dealer)
140	{
141	dealer->args_parse = wamp_dealer_call_dummy_param;
142	dealer->call_close = wamp_dealer_none_close;
143
144	memset(&dealer->params, 0, sizeof(dealer->params));
145	}
146
147	void wamp_dealer_call_request_id(wamp_dealer_t dealer, const char value)
148	{
149	dealer->requestId = atoi(value);
150	}
151
152	void wamp_dealer_call_options(wamp_dealer_t dealer, const char value)
153	{
154	}
155
156	void wamp_dealer_call_options_param(wamp_dealer_t *dealer, jsonsl_action_t action,
157	struct jsonsl_state_st state, const char buf)
158	{
159	static const char deviceId[] = "deviceId";
160
161	switch (state->level) {
162	case 3:
163	switch (action){
164	case JSONSL_ACTION_POP:
165	switch (state->type)
166	{
167	case JSONSL_T_HKEY:
168	if(strcmp(deviceId, dealer->s->jsn_buf) == 0){
169	dealer->state = WAMP_DEALER_STATE_DEVICE_ID;
170	}
171	break;
172	case JSONSL_T_SPECIAL:
173	dealer->current_device = wamp_dealer_get_device(dealer, atoi(dealer->s->jsn_buf));
174	break;
175	default:
176	break;
177	}
178	break;
179	}
180	break;
181	}
182	}
183
184	void wamp_dealer_call_procedure(wamp_dealer_t dealer, const char value)
185	{
186	static const char getDeviceList[] = "com.sonycsl.kadecot.provider.procedure.getDeviceList";
187	static const char kadecotGet[] = "com.sonycsl.kadecot.echonetlite.procedure.get";
188	static const char kadecotSet[] = "com.sonycsl.kadecot.echonetlite.procedure.set";
189	static const char getDeviceInfo[] = "jp.toppers.ecnl.procedure.getDeviceInfo";
190	static const char ecnlSet[] = "jp.toppers.ecnl.procedure.set";
191	static const char ecnlGet[] = "jp.toppers.ecnl.procedure.get";
192	static const char ecnlSetGet[] = "jp.toppers.ecnl.procedure.setget";
193	static const char pinMode[] = "com.sonycsl.kadecot.arduino.pinMode";
194	static const char digitalWrite[] = "com.sonycsl.kadecot.arduino.digitalWrite";
195	static const char digitalRead[] = "com.sonycsl.kadecot.arduino.digitalRead";
196	static const char analogRead[] = "com.sonycsl.kadecot.arduino.analogRead";
197	static const char analogWrite[] = "com.sonycsl.kadecot.arduino.analogWrite";
198	static const char setInitParams[] = "jp.toppers.ecnl.procedure.setInitParams";
199	static const char getInitParams[] = "jp.toppers.ecnl.procedure.getInitParams";
200
201	if(strcmp(getDeviceList, value) == 0){
202	dealer->procedure = WAMP_DEALER_PROCEDURE_GET_DEVICELIST;
203	dealer->args_parse = wamp_dealer_call_dummy_param;
204	dealer->call_close = wamp_dealer_get_devicelist_close;
205	}
206	else if(strcmp(kadecotGet, value) == 0){
207	dealer->procedure = WAMP_DEALER_PROCEDURE_KADECOT_GET;
208	dealer->args_parse = wamp_dealer_call_kadecot_param;
209	dealer->call_close = wamp_dealer_kadecot_get_close;
210	}
211	else if(strcmp(kadecotSet, value) == 0){
212	dealer->procedure = WAMP_DEALER_PROCEDURE_KADECOT_SET;
213	dealer->args_parse = wamp_dealer_call_kadecot_param;
214	dealer->call_close = wamp_dealer_kadecot_set_close;
215	}
216	else if(strcmp(getDeviceInfo, value) == 0){
217	dealer->procedure = WAMP_DEALER_PROCEDURE_GET_DEVICEINFO;
218	dealer->args_parse = wamp_dealer_call_dummy_param;
219	dealer->call_close = wamp_dealer_get_deviceinfo_close;
220	}
221	else if(strcmp(ecnlSet, value) == 0){
222	dealer->procedure = WAMP_DEALER_PROCEDURE_ECNL_SET;
223	dealer->args_parse = wamp_dealer_call_ecnl_param;
224	dealer->call_close = wamp_dealer_ecnl_set_close;
225	}
226	else if(strcmp(ecnlGet, value) == 0){
227	dealer->procedure = WAMP_DEALER_PROCEDURE_ECNL_GET;
228	dealer->args_parse = wamp_dealer_call_ecnl_param;
229	dealer->call_close = wamp_dealer_ecnl_get_close;
230	}
231	else if(strcmp(ecnlSetGet, value) == 0){
232	dealer->procedure = WAMP_DEALER_PROCEDURE_ECNL_SETGET;
233	dealer->args_parse = wamp_dealer_call_ecnl_param;
234	dealer->call_close = wamp_dealer_ecnl_setget_close;
235	}
236	else if(strcmp(pinMode, value) == 0){
237	dealer->procedure = WAMP_DEALER_PROCEDURE_PIN_MODE;
238	dealer->args_parse = wamp_dealer_call_arduino_param;
239	dealer->call_close = wamp_dealer_pin_mode_close;
240	}
241	else if(strcmp(digitalWrite, value) == 0){
242	dealer->procedure = WAMP_DEALER_PROCEDURE_DIGITAL_WRITE;
243	dealer->args_parse = wamp_dealer_call_arduino_param;
244	dealer->call_close = wamp_dealer_digital_write_close;
245	}
246	else if(strcmp(digitalRead, value) == 0){
247	dealer->procedure = WAMP_DEALER_PROCEDURE_DIGITAL_READ;
248	dealer->args_parse = wamp_dealer_call_arduino_param;
249	dealer->call_close = wamp_dealer_digital_read_close;
250	}
251	else if(strcmp(analogRead, value) == 0){
252	dealer->procedure = WAMP_DEALER_PROCEDURE_ANALOG_READ;
253	dealer->args_parse = wamp_dealer_call_arduino_param;
254	dealer->call_close = wamp_dealer_analog_read_close;
255	}
256	else if(strcmp(analogWrite, value) == 0){
257	dealer->procedure = WAMP_DEALER_PROCEDURE_ANALOG_WRITE;
258	dealer->args_parse = wamp_dealer_call_arduino_param;
259	dealer->call_close = wamp_dealer_analog_write_close;
260	}
261	else if(strcmp(setInitParams, value) == 0){
262	dealer->procedure = WAMP_DEALER_PROCEDURE_SET_INIT_PARAMS;
263	dealer->args_parse = wamp_dealer_call_init_params_param;
264	dealer->call_close = wamp_dealer_set_init_params_close;
265	}
266	else if (strcmp(getInitParams, value) == 0) {
267	dealer->procedure = WAMP_DEALER_PROCEDURE_GET_INIT_PARAMS;
268	dealer->args_parse = wamp_dealer_call_init_params_param;
269	dealer->call_close = wamp_dealer_get_init_params_close;
270	}
271	else{
272	dealer->procedure = WAMP_DEALER_PROCEDURE_NONE;
273	dealer->args_parse = wamp_dealer_call_dummy_param;
274	dealer->call_close = wamp_dealer_none_close;
275	}
276	}
277
278	void wamp_dealer_call_arguments(wamp_dealer_t dealer, const char value)
279	{
280	}
281
282	void wamp_dealer_call_arguments_param(wamp_dealer_t *dealer, jsonsl_action_t action,
283	struct jsonsl_state_st state, const char buf)
284	{
285	}
286
287	void wamp_dealer_call_argumentskw(wamp_dealer_t dealer, const char value)
288	{
289	}
290
291	void wamp_dealer_call_argumentskw_param(wamp_dealer_t *dealer, jsonsl_action_t action,
292	struct jsonsl_state_st state, const char buf)
293	{
294	dealer->args_parse(dealer, action, state, buf);
295	}
296
297	static void wamp_dealer_call_dummy_param(wamp_dealer_t *dealer,
298	jsonsl_action_t action, struct jsonsl_state_st state, const char buf)
299	{
300	}
301
302	static void wamp_dealer_call_kadecot_param(wamp_dealer_t *dealer,
303	jsonsl_action_t action, struct jsonsl_state_st state, const char buf)
304	{
305	static const char propertyName[] = "propertyName";
306	static const char propertyValue[] = "propertyValue";
307
308	switch (state->level) {
309	case 3:
310	switch (action){
311	case JSONSL_ACTION_POP:
312	switch (state->type)
313	{
314	case JSONSL_T_HKEY:
315	if(strcmp(propertyName, dealer->s->jsn_buf) == 0){
316	dealer->state = WAMP_DEALER_STATE_PROPERTY_NAME;
317	}
318	else if(strcmp(propertyValue, dealer->s->jsn_buf) == 0){
319	dealer->state = WAMP_DEALER_STATE_PROPERTY_VALUE;
320	dealer->params.pdc = 0;
321	memset(dealer->params.edt, 0, sizeof(dealer->params.edt));
322	}
323	break;
324	case JSONSL_T_STRING:
325	switch(dealer->state){
326	case WAMP_DEALER_STATE_PROPERTY_NAME:
327	memcpy(dealer->params.prop_name, dealer->s->jsn_buf, sizeof(dealer->params.prop_name));
328	wamp_dealer_get_epc(dealer->params.prop_name, strnlen(dealer->params.prop_name,
329	sizeof(dealer->params.prop_name)),
330	dealer->current_device->deviceType,
331	&dealer->params.epc, &dealer->params.pdc);
332	break;
333	}
334	break;
335	default:
336	break;
337	}
338	break;
339	}
340	break;
341	case 4:
342	switch (action){
343	case JSONSL_ACTION_POP:
344	switch (state->type)
345	{
346	case JSONSL_T_SPECIAL:
347	switch(dealer->state){
348	case WAMP_DEALER_STATE_PROPERTY_VALUE:
349	dealer->params.edt[dealer->params.pdc++] = atoi(dealer->s->jsn_buf);
350	break;
351	}
352	break;
353	}
354	break;
355	}
356	break;
357	}
358	}
359
360	static void wamp_dealer_call_ecnl_param(wamp_dealer_t *dealer,
361	jsonsl_action_t action, struct jsonsl_state_st state, const char buf)
362	{
363	static const char deojId[] = "deojid";
364	static const char properties[] = "properties";
365	static const char propertyCode[] = "epc";
366	static const char propertyValue[] = "edt";
367
368	switch (state->level) {
369	case 3:
370	switch (action){
371	case JSONSL_ACTION_POP:
372	switch (state->type)
373	{
374	case JSONSL_T_HKEY:
375	if(strcmp(deojId, dealer->s->jsn_buf) == 0){
376	dealer->state = WAMP_DEALER_STATE_DEOJID;
377	}
378	else if(strcmp(properties, dealer->s->jsn_buf) == 0){
379	dealer->state = WAMP_DEALER_STATE_PROPERTIES;
380	}
381	break;
382	case JSONSL_T_SPECIAL:
383	switch(dealer->state){
384	case WAMP_DEALER_STATE_DEOJID:
385	dealer->params.deojid = atoi(dealer->s->jsn_buf);
386	break;
387	}
388	break;
389	}
390	break;
391	case JSONSL_ACTION_PUSH:
392	switch (state->type)
393	{
394	case JSONSL_T_LIST:
395	switch(dealer->state){
396	case WAMP_DEALER_STATE_PROPERTIES:
397	dealer->state = WAMP_DEALER_STATE_PROPERTY_LIST;
398	break;
399	}
400	break;
401	default:
402	break;
403	}
404	break;
405	}
406	break;
407	case 4:
408	switch (action){
409	case JSONSL_ACTION_POP:
410	switch (state->type)
411	{
412	case JSONSL_T_SPECIAL:
413	switch(dealer->state){
414	}
415	break;
416	default:
417	break;
418	}
419	break;
420	}
421	break;
422	case 5:
423	switch (action){
424	case JSONSL_ACTION_POP:
425	switch (state->type)
426	{
427	case JSONSL_T_HKEY:
428	if(strcmp(propertyCode, dealer->s->jsn_buf) == 0){
429	dealer->state = WAMP_DEALER_STATE_PROPERTY_CODE;
430	}
431	else if(strcmp(propertyValue, dealer->s->jsn_buf) == 0){
432	dealer->state = WAMP_DEALER_STATE_PROPERTY_VALUE;
433	dealer->params.pdc = 0;
434	memset(dealer->params.edt, 0, sizeof(dealer->params.edt));
435	}
436	break;
437	case JSONSL_T_SPECIAL:
438	switch(dealer->state){
439	case WAMP_DEALER_STATE_PROPERTY_CODE:
440	dealer->params.epc = atoi(dealer->s->jsn_buf);
441	switch(dealer->procedure){
442	case WAMP_DEALER_PROCEDURE_ECNL_GET:
443	if (dealer->ecnl_mag == NULL){
444	ecn_esv_get(&dealer->ecnl_mag, dealer->params.deojid, dealer->params.epc);
445	}
446	else{
447	ecn_add_epc(dealer->ecnl_mag, dealer->params.epc);
448	}
449	break;
450	case WAMP_DEALER_PROCEDURE_ECNL_SETGET:
451	ecn_add_epc(dealer->ecnl_mag, dealer->params.epc);
452	break;
453	}
454	break;
455	}
456	break;
457	case JSONSL_T_STRING:
458	switch(dealer->state){
459	case WAMP_DEALER_STATE_PROPERTY_VALUE:
460	dealer->params.pdc = wamp_stob(dealer->s->jsn_buf, dealer->params.edt, sizeof(dealer->params.edt));
461	switch(dealer->procedure){
462	case WAMP_DEALER_PROCEDURE_ECNL_SET:
463	if (dealer->ecnl_mag == NULL){
464	ecn_esv_setc(&dealer->ecnl_mag, dealer->params.deojid, dealer->params.epc,
465	dealer->params.pdc, dealer->params.edt);
466	}
467	else{
468	ecn_add_edt(dealer->ecnl_mag, dealer->params.epc,
469	dealer->params.pdc, dealer->params.edt);
470	}
471	break;
472	case WAMP_DEALER_PROCEDURE_ECNL_SETGET:
473	if (dealer->ecnl_mag == NULL){
474	ecn_esv_set_get(&dealer->ecnl_mag, dealer->params.deojid, dealer->params.epc,
475	dealer->params.pdc, dealer->params.edt);
476	}
477	else{
478	ecn_add_edt(dealer->ecnl_mag, dealer->params.epc,
479	dealer->params.pdc, dealer->params.edt);
480	}
481	break;
482	}
483	break;
484	}
485	break;
486	}
487	break;
488	}
489	break;
490	}
491	}
492
493	static void wamp_dealer_call_arduino_param(wamp_dealer_t *dealer,
494	jsonsl_action_t action, struct jsonsl_state_st state, const char buf)
495	{
496	static const char pin[] = "pin";
497	static const char mode[] = "mode";
498	static const char value[] = "value";
499	static const char INPUT[] = "INPUT";
500	static const char OUTPUT[] = "OUTPUT";
501	static const char INPUT_PULLUP[] = "INPUT_PULLUP";
502	static const char HIGH[] = "HIGH";
503	static const char LOW[] = "LOW";
504
505	switch (state->level) {
506	case 3:
507	switch (action){
508	case JSONSL_ACTION_POP:
509	switch (state->type)
510	{
511	case JSONSL_T_HKEY:
512	if(strcmp(pin, dealer->s->jsn_buf) == 0){
513	dealer->state = WAMP_DEALER_STATE_PIN;
514	}
515	else if(strcmp(mode, dealer->s->jsn_buf) == 0){
516	dealer->state = WAMP_DEALER_STATE_MODE;
517	}
518	else if(strcmp(value, dealer->s->jsn_buf) == 0){
519	if(dealer->procedure == WAMP_DEALER_PROCEDURE_DIGITAL_WRITE)
520	dealer->state = WAMP_DEALER_STATE_DIGITAL_VALUE;
521	else if(dealer->procedure == WAMP_DEALER_PROCEDURE_ANALOG_WRITE)
522	dealer->state = WAMP_DEALER_STATE_ANALOG_VALUE;
523	}
524	break;
525	case JSONSL_T_STRING:
526	switch(dealer->state){
527	case WAMP_DEALER_STATE_MODE:
528	if(strcmp(INPUT, dealer->s->jsn_buf) == 0){
529	dealer->arduino_params.mode = WAMP_DEALER_PIN_MODE_INPUT;
530	}
531	else if(strcmp(OUTPUT, dealer->s->jsn_buf) == 0){
532	dealer->arduino_params.mode = WAMP_DEALER_PIN_MODE_OUTPUT;
533	}
534	else if(strcmp(INPUT_PULLUP, dealer->s->jsn_buf) == 0){
535	dealer->arduino_params.mode = WAMP_DEALER_PIN_MODE_INPUT_PULLUP;
536	}
537	break;
538	case WAMP_DEALER_STATE_DIGITAL_VALUE:
539	if(strcmp(HIGH, dealer->s->jsn_buf) == 0){
540	dealer->arduino_params.digval = WAMP_DEALER_DIGITAL_VALUE_HIGH;
541	}
542	else if(strcmp(LOW, dealer->s->jsn_buf) == 0){
543	dealer->arduino_params.digval = WAMP_DEALER_DIGITAL_VALUE_LOW;
544	}
545	break;
546	}
547	break;
548	case JSONSL_T_SPECIAL:
549	switch(dealer->state){
550	case WAMP_DEALER_STATE_PIN:
551	dealer->arduino_params.pin = atoi(dealer->s->jsn_buf);
552	break;
553	case WAMP_DEALER_STATE_ANALOG_VALUE:
554	dealer->arduino_params.anaval = atoi(dealer->s->jsn_buf);
555	break;
556	}
557	break;
558	default:
559	break;
560	}
561	break;
562	}
563	break;
564	}
565	}
566
567	static void wamp_dealer_call_init_params_param(wamp_dealer_t *dealer,
568	jsonsl_action_t action, struct jsonsl_state_st state, const char buf)
569	{
570	static const char macAddr[] = "macAddr";
571	static const char dhcpEnable[] = "dhcpEnable";
572	static const char ipAddr[] = "ipAddr";
573	static const char netmask[] = "netmask";
574	static const char gateway[] = "gateway";
575
576	switch (state->level) {
577	case 3:
578	switch (action){
579	case JSONSL_ACTION_POP:
580	switch (state->type)
581	{
582	case JSONSL_T_HKEY:
583	if(strcmp(macAddr, dealer->s->jsn_buf) == 0){
584	dealer->state = WAMP_DEALER_STATE_MAC_ADDR_VALUE;
585	dealer->init_params.pos = 0;
586	memset(&dealer->init_params.mac_addr, 0, sizeof(dealer->init_params.mac_addr));
587	}
588	if(strcmp(dhcpEnable, dealer->s->jsn_buf) == 0){
589	dealer->state = WAMP_DEALER_STATE_DHCP_ENABLE_VALUE;
590	dealer->init_params.dhcp_enable = false;
591	}
592	if(strcmp(ipAddr, dealer->s->jsn_buf) == 0){
593	dealer->state = WAMP_DEALER_STATE_IP_ADDR_VALUE;
594	dealer->init_params.pos = 0;
595	memset(&dealer->init_params.ip_addr, 0, sizeof(dealer->init_params.ip_addr));
596	}
597	if(strcmp(netmask, dealer->s->jsn_buf) == 0){
598	dealer->state = WAMP_DEALER_STATE_NETMASK_VALUE;
599	dealer->init_params.pos = 0;
600	memset(&dealer->init_params.netmask, 0, sizeof(dealer->init_params.netmask));
601	}
602	if(strcmp(gateway, dealer->s->jsn_buf) == 0){
603	dealer->state = WAMP_DEALER_STATE_GATEWAY_VALUE;
604	dealer->init_params.pos = 0;
605	memset(&dealer->init_params.gateway, 0, sizeof(dealer->init_params.gateway));
606	}
607	break;
608	case JSONSL_T_SPECIAL:
609	switch(dealer->state){
610	case WAMP_DEALER_STATE_DHCP_ENABLE_VALUE:
611	dealer->init_params.dhcp_enable = strcmp("true", dealer->s->jsn_buf) == 0;
612	break;
613	}
614	break;
615	default:
616	break;
617	}
618	break;
619	}
620	break;
621	case 4:
622	switch (action){
623	case JSONSL_ACTION_POP:
624	switch (state->type)
625	{
626	case JSONSL_T_SPECIAL:
627	switch(dealer->state){
628	case WAMP_DEALER_STATE_MAC_ADDR_VALUE:
629	dealer->init_params.mac_addr[dealer->init_params.pos++] = atoi(dealer->s->jsn_buf);
630	break;
631	case WAMP_DEALER_STATE_IP_ADDR_VALUE:
632	dealer->init_params.ip_addr[dealer->init_params.pos++] = atoi(dealer->s->jsn_buf);
633	break;
634	case WAMP_DEALER_STATE_NETMASK_VALUE:
635	dealer->init_params.netmask[dealer->init_params.pos++] = atoi(dealer->s->jsn_buf);
636	break;
637	case WAMP_DEALER_STATE_GATEWAY_VALUE:
638	dealer->init_params.gateway[dealer->init_params.pos++] = atoi(dealer->s->jsn_buf);
639	break;
640	}
641	break;
642	}
643	break;
644	}
645	break;
646	}
647	}
648
649	void wamp_dealer_call_close(struct wamp_state *s)
650	{
651	wamp_dealer_t *dealer = &s->dealer;
652	ER ret;
653
654	dealer->error = internal_error;
655
656	// send RESULT
657	dealer->call_close(dealer);
658
659	if (dealer->error != NULL){
660	ret = wamp_send_error_res(s, WAMP_CODE_CALL, dealer->requestId, dealer->error);
661	if (ret != E_OK) {
662	syslog(LOG_WARNING, "wamp_dealer_call_close() : wamp_send_error_res() result = %d", ret);
663	}
664	dealer->error = NULL;
665	}
666	}
667
668	static void wamp_dealer_none_close(struct wamp_dealer *dealer)
669	{
670	wamp_state_t *s = dealer->s;
671	ER ret;
672
673	dealer->error = NULL;
674	ret = wamp_send_error_res(s, WAMP_CODE_CALL, dealer->requestId, invalid_request);
675	if (ret != E_OK) {
676	syslog(LOG_WARNING, "wamp_dealer_none_close() : wamp_send_error_res() result = %d", ret);
677	}
678	}
679
680	static void wamp_dealer_get_devicelist_close(struct wamp_dealer *dealer)
681	{
682	dealer->error = NULL;
683	main_get_device_list(dealer->requestId, dealer);
684	}
685
686	void wamp_dealer_set_devicelist(struct wamp_dealer *dealer, ECN_FBS_ID msg)
687	{
688	wamp_state_t *s = dealer->s;
689	ecn_inm_get_device_item_t device;
690	ECN_FBS_SSIZE_T rlen;
691	echonetlite_device_t dev, end = &dealer->devices[sizeof(dealer->devices) / sizeof(dealer->devices[0])];
692	ER ret;
693
694	/* 機器情報をクリア */
695	for(dev = dealer->devices; dev < end; dev++){
696	dev->deviceId = 0;
697	}
698
699	/* メッセージから機器情報を作成 */
700	for(dev = dealer->devices; dev < end; ){
701	ret = _ecn_fbs_get_data(msg, &device, sizeof(device), &rlen);
702	if ((ret != E_OK) \|\| (rlen != sizeof(device)))
703	break;
704
705	if (device.enodid == 0)
706	continue;
707
708	dev->deviceId = device.eobjid;
709	dev->nodeId = device.enodid;
710	dev->addrId = device.addrid;
711	dev->deviceType = (device.eojx1 << 8) \| device.eojx2;
712	dev->x3 = device.eojx3;
713	dev->status = device.state != 0;
714
715	dev++;
716	}
717
718	dealer->current_device = &dealer->devices[0];
719	dealer->devices_pos = 0;
720	main_get_device_ipaddr(dealer->requestId, dealer, dealer->current_device->addrId);
721	}
722
723	void wamp_dealer_get_devicelist_timeout(struct wamp_dealer *dealer)
724	{
725	wamp_state_t *s = dealer->s;
726	ER ret;
727
728	ret = wamp_send_error_res(s, WAMP_CODE_CALL, dealer->requestId, internal_error);
729	if (ret != E_OK) {
730	syslog(LOG_WARNING, "wamp_dealer_get_devicelist_timeout() : wamp_send_error_res() result = %d", ret);
731	}
732	}
733
734	void wamp_dealer_set_ipaddr(struct wamp_dealer dealer, char ipaddr)
735	{
736	echonetlite_device_t dev, end = &dealer->devices[sizeof(dealer->devices) / sizeof(dealer->devices[0])];
737	int i, devicePos;
738
739	dev = dealer->current_device;
740	if ((dev != NULL) && (ipaddr != NULL)){
741	strcpy_s(dev->ip_addr, sizeof(dev->ip_addr), ipaddr);
742
743	kadecot_names_get_device_type_name(dev->deviceType, dev->deviceTypeStr, sizeof(dev->deviceTypeStr));
744	strcpy_s(dev->description, sizeof(dev->description), dev->deviceTypeStr);
745	strcpy_s(dev->nickname, sizeof(dev->nickname), dev->deviceTypeStr);
746	}
747
748	devicePos = sizeof(dealer->devices) / sizeof(dealer->devices[0]);
749	for(i = dealer->devices_pos + 1, dev = &dealer->devices[i]; dev < end; i++, dev++){
750	if(dev->deviceId == 0)
751	continue;
752
753	devicePos = i;
754	break;
755	}
756
757	if (devicePos == sizeof(dealer->devices) / sizeof(dealer->devices[0])){
758	dealer->current_device = NULL;
759	dealer->devices_pos = 0;
760	wamp_dealer_get_devicelist(dealer);
761	}
762	else{
763	dealer->current_device = &dealer->devices[devicePos];
764	dealer->devices_pos = devicePos;
765	main_get_device_ipaddr(dealer->requestId, dealer, dealer->current_device->addrId);
766	}
767	}
768
769	void wamp_dealer_get_ipaddr_timeout(struct wamp_dealer *dealer)
770	{
771	wamp_state_t *s = dealer->s;
772	ER ret;
773
774	ret = wamp_send_error_res(s, WAMP_CODE_CALL, dealer->requestId, internal_error);
775	if (ret != E_OK) {
776	syslog(LOG_WARNING, "wamp_dealer_get_ipaddr_timeout() : wamp_send_error_res() result = %d", ret);
777	}
778	}
779
780	static void wamp_dealer_get_devicelist(struct wamp_dealer *dealer)
781	{
782	wamp_state_t *s = dealer->s;
783	echonetlite_device_t dev, end = &dealer->devices[sizeof(dealer->devices) / sizeof(dealer->devices[0])];
784	ECN_FBS_ID buf;
785	ECN_FBS_SSIZE_T pos = 0, start;
786	char ip_addr[16];
787	ER ret;
788
789	ret = _ecn_fbs_cre(1, &buf);
790	if (ret != E_OK) {
791	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
792	return;
793	}
794
795	ret = fbs_printf(buf, &pos, "[50,%d,{},[],", dealer->requestId);
796	if (ret != E_OK) {
797	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
798	_ecn_fbs_del(buf);
799	return;
800	}
801
802	ret = fbs_printf(buf, &pos, "{\"deviceList\":["
803	"{\"description\":\"GR-SAKURA\",\"deviceId\":1,\"deviceType\":\"GrSakura\",\"ip_addr\":\"%s\",\"nickname\":\"GR-SAKURA\",\"protocol\":\"arduino\",\"status\":true},",
804	ip2str(ip_addr, uip_hostaddr));
805	if (ret != E_OK) {
806	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
807	_ecn_fbs_del(buf);
808	return;
809	}
810
811	start = pos;
812	for(dev = dealer->devices; dev < end; dev++){
813	if(dev->deviceId == 0)
814	continue;
815
816	ret = fbs_printf(buf, &pos, "{\"description\":\"%s\",\"deviceId\":%d,\"deviceType\":\"%s\",\"ip_addr\":\"%s\",\"nickname\":\"%s\",\"protocol\":\"echonetlite\",\"status\":%s},",
817	dev->description, dev->deviceId, dev->deviceTypeStr, dev->ip_addr, dev->nickname, dev->status ? "true" : "false");
818	if (ret != E_OK) {
819	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
820	_ecn_fbs_del(buf);
821	return;
822	}
823	}
824
825	/* 最後の","を消す */
826	if(start != pos)
827	pos--;
828
829	ret = fbs_printf(buf, &pos, "]}]");
830	if (ret != E_OK) {
831	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
832	_ecn_fbs_del(buf);
833	return;
834	}
835
836	ret = main_send_message(buf, s->wbsid);
837	if (ret != E_OK) {
838	syslog(LOG_WARNING, "wamp_dealer_get_devicelist() : main_send_message() result = %d", ret);
839	}
840	}
841
842	static void wamp_dealer_kadecot_get_close(struct wamp_dealer *dealer)
843	{
844	echonetlite_device_t *device = dealer->current_device;
845	uint16_t devType;
846
847	if(device == NULL)
848	return;
849
850	devType = device->deviceType;
851	if(devType == 0)
852	return;
853
854	if (dealer->params.epc == 0) {
855	dealer->error = method_not_found;
856	syslog(7, method_not_found);
857	return;
858	}
859
860	dealer->error = NULL;
861	main_kadecot_get(dealer->requestId, dealer, device->deviceId, dealer->params.epc);
862	}
863
864	void wamp_dealer_kadecot_get(struct wamp_dealer *dealer, int deviceId, uint8_t epc,
865	uint8_t pdc, uint8_t *edt)
866	{
867	wamp_state_t *s = dealer->s;
868	ECN_FBS_ID buf;
869	ECN_FBS_SSIZE_T pos = 0, start;
870	int i;
871	const char *propName;
872	ER ret;
873
874	ret = _ecn_fbs_cre(1, &buf);
875	if (ret != E_OK) {
876	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
877	return;
878	}
879
880	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":%d},[],",
881	dealer->requestId, deviceId);
882	if (ret != E_OK) {
883	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
884	_ecn_fbs_del(buf);
885	return;
886	}
887
888	propName = dealer->params.prop_name;
889	if(propName[0] != '\0'){
890	ret = fbs_printf(buf, &pos, "{\"propertyName\":\"%s\",\"propertyValue\":[",
891	propName);
892	if (ret != E_OK) {
893	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
894	_ecn_fbs_del(buf);
895	return;
896	}
897	}
898	else{
899	ret = fbs_printf(buf, &pos, "{\"propertyName\":\"0x%02x\",\"propertyValue\":[",
900	epc);
901	if (ret != E_OK) {
902	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
903	_ecn_fbs_del(buf);
904	return;
905	}
906	}
907
908	start = pos;
909	for(i = 0; i < pdc; i++){
910	ret = fbs_printf(buf, &pos, "%d,", edt[i]);
911	if (ret != E_OK) {
912	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
913	_ecn_fbs_del(buf);
914	return;
915	}
916	}
917
918	/* 最後の","を消す */
919	if(start != pos)
920	pos--;
921
922	ret = fbs_printf(buf, &pos, "]}]");
923	if (ret != E_OK) {
924	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
925	_ecn_fbs_del(buf);
926	return;
927	}
928
929	ret = main_send_message(buf, s->wbsid);
930	if (ret != E_OK) {
931	syslog(LOG_WARNING, "wamp_dealer_kadecot_get() : main_send_message() result = %d", ret);
932	}
933	}
934
935	void wamp_dealer_kadecot_set_timeout(struct wamp_dealer *dealer)
936	{
937	wamp_state_t *s = dealer->s;
938	ER ret;
939
940	ret = wamp_send_error_res(s, WAMP_CODE_CALL, dealer->requestId, internal_error);
941	if (ret != E_OK) {
942	syslog(LOG_WARNING, "wamp_dealer_kadecot_set_timeout() : wamp_send_error_res() result = %d", ret);
943	}
944	}
945
946	static void wamp_dealer_kadecot_set_close(struct wamp_dealer *dealer)
947	{
948	echonetlite_device_t *device = dealer->current_device;
949	uint16_t devType;
950
951	if(device == NULL)
952	return;
953
954	devType = device->deviceType;
955	if(devType == 0)
956	return;
957
958	if(dealer->params.epc == 0){
959	dealer->error = method_not_found;
960	return;
961	}
962
963	dealer->error = NULL;
964	main_kadecot_set(dealer->requestId, dealer, device->deviceId, dealer->params.epc,
965	dealer->params.pdc, dealer->params.edt);
966	}
967
968	void wamp_dealer_kadecot_set(struct wamp_dealer *dealer, int deviceId, uint8_t epc)
969	{
970	wamp_state_t *s = dealer->s;
971	ECN_FBS_ID buf;
972	ECN_FBS_SSIZE_T pos = 0, start;
973	int i;
974	const char *propName;
975	ER ret;
976
977	ret = _ecn_fbs_cre(1, &buf);
978	if (ret != E_OK) {
979	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
980	return;
981	}
982
983	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":%d},[],",
984	dealer->requestId, deviceId);
985	if (ret != E_OK) {
986	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
987	_ecn_fbs_del(buf);
988	return;
989	}
990
991	propName = dealer->params.prop_name;
992	if(propName[0] != '\0'){
993	ret = fbs_printf(buf, &pos, "{\"propertyName\":\"%s\",\"propertyValue\":[",
994	propName);
995	if (ret != E_OK) {
996	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
997	_ecn_fbs_del(buf);
998	return;
999	}
1000	}
1001	else{
1002	ret = fbs_printf(buf, &pos, "{\"propertyName\":\"0x%02x\",\"propertyValue\":[",
1003	epc);
1004	if (ret != E_OK) {
1005	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1006	_ecn_fbs_del(buf);
1007	return;
1008	}
1009	}
1010
1011	start = pos;
1012	for(i = 0; i < dealer->params.pdc; i++){
1013	ret = fbs_printf(buf, &pos, "%d,", dealer->params.edt[i]);
1014	if (ret != E_OK) {
1015	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1016	_ecn_fbs_del(buf);
1017	return;
1018	}
1019	}
1020
1021	/* 最後の","を消す */
1022	if(start != pos)
1023	pos--;
1024
1025	ret = fbs_printf(buf, &pos, "]}]");
1026	if (ret != E_OK) {
1027	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1028	_ecn_fbs_del(buf);
1029	return;
1030	}
1031
1032	ret = main_send_message(buf, s->wbsid);
1033	if (ret != E_OK) {
1034	syslog(LOG_WARNING, "wamp_dealer_kadecot_set() : main_send_message() result = %d", ret);
1035	}
1036	}
1037
1038	void wamp_dealer_kadecot_get_timeout(struct wamp_dealer *dealer)
1039	{
1040	wamp_state_t *s = dealer->s;
1041	ER ret;
1042
1043	ret = wamp_send_error_res(s, WAMP_CODE_CALL, dealer->requestId, internal_error);
1044	if (ret != E_OK) {
1045	syslog(LOG_WARNING, "wamp_dealer_kadecot_get_timeout() : wamp_send_error_res() result = %d", ret);
1046	}
1047	}
1048
1049	static void wamp_dealer_get_deviceinfo_close(struct wamp_dealer *dealer)
1050	{
1051	echonetlite_device_t *device = dealer->current_device;
1052	if(device == NULL)
1053	return;
1054
1055	dealer->error = NULL;
1056	main_get_device_info(dealer->requestId, dealer, device->deviceId);
1057	}
1058
1059	void wamp_dealer_set_deviceinfo(struct wamp_dealer dealer, int deviceId, uint8_t pmset,
1060	uint8_t pmget, uint8_t pmanno)
1061	{
1062	wamp_state_t *s = dealer->s;
1063	echonetlite_device_t *device = dealer->current_device;
1064	ECN_FBS_ID buf;
1065	ECN_FBS_SSIZE_T pos = 0;
1066	int i, j, m, prop;
1067	ER ret;
1068
1069	if(device == NULL)
1070	return;
1071
1072	ret = _ecn_fbs_cre(1, &buf);
1073	if (ret != E_OK) {
1074	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1075	return;
1076	}
1077
1078	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":%d},[],",
1079	dealer->requestId, deviceId);
1080	if (ret != E_OK) {
1081	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1082	_ecn_fbs_del(buf);
1083	return;
1084	}
1085
1086	ret = fbs_printf(buf, &pos, "{\"x1\":%d,\"x2\":%d,\"x3\":%d,\"enodid\":%d,\"properties\":[",
1087	device->deviceType >> 8, device->deviceType & 0xFF, device->x3, device->nodeId);
1088	if (ret != E_OK) {
1089	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1090	_ecn_fbs_del(buf);
1091	return;
1092	}
1093
1094	prop = pos;
1095	for(i = 0; i < 16; i++){
1096	uint8_t pms = pmset[i], pmg = pmget[i], pma = pmanno[i], exs = pms \| pmg \| pma;
1097
1098	for(j = 0; j < 8; j++){
1099	m = 1 << j;
1100	if(!(exs & m))
1101	continue;
1102
1103	ret = fbs_printf(buf, &pos, "{\"epc\":%d,\"flag\":\"", 0x80 \| (j << 4) \| i);
1104	if (ret != E_OK) {
1105	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1106	_ecn_fbs_del(buf);
1107	return;
1108	}
1109	if (pms & m) {
1110	ret = fbs_printf(buf, &pos, "RULE_SET,");
1111	if (ret != E_OK) {
1112	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1113	_ecn_fbs_del(buf);
1114	return;
1115	}
1116	}
1117	if (pmg & m) {
1118	ret = fbs_printf(buf, &pos, "RULE_GET,");
1119	if (ret != E_OK) {
1120	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1121	_ecn_fbs_del(buf);
1122	return;
1123	}
1124	}
1125	if (pma & m) {
1126	ret = fbs_printf(buf, &pos, "ANNOUNCE,");
1127	if (ret != E_OK) {
1128	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1129	_ecn_fbs_del(buf);
1130	return;
1131	}
1132	}
1133	/* 最後の","を消す */
1134	pos--;
1135
1136	ret = fbs_printf(buf, &pos, "\"},");
1137	if (ret != E_OK) {
1138	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1139	_ecn_fbs_del(buf);
1140	return;
1141	}
1142	}
1143	}
1144
1145	/* 最後の","を消す */
1146	if(prop != pos)
1147	pos--;
1148
1149	ret = fbs_printf(buf, &pos, "]}]");
1150	if (ret != E_OK) {
1151	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1152	_ecn_fbs_del(buf);
1153	return;
1154	}
1155
1156	ret = main_send_message(buf, s->wbsid);
1157	if (ret != E_OK) {
1158	syslog(LOG_WARNING, "wamp_dealer_set_deviceinfo() : main_send_message() result = %d", ret);
1159	}
1160	}
1161
1162	void wamp_dealer_get_deviceinfo_timeout(struct wamp_dealer *dealer)
1163	{
1164	wamp_state_t *s = dealer->s;
1165	ER ret;
1166
1167	ret = wamp_send_error_res(s, WAMP_CODE_CALL, dealer->requestId, internal_error);
1168	if (ret != E_OK) {
1169	syslog(LOG_WARNING, "wamp_dealer_get_deviceinfo_timeout() : wamp_send_error_res() result = %d", ret);
1170	}
1171	}
1172
1173	static void wamp_dealer_ecnl_set_close(struct wamp_dealer *dealer)
1174	{
1175	ER ret;
1176	echonetlite_device_t *device = dealer->current_device;
1177	ECN_FBS_ID buf = { (T_ECN_FST_BLK *)dealer->ecnl_mag };
1178
1179	if (dealer->ecnl_mag == NULL)
1180	return;
1181
1182	if(device == NULL){
1183	_ecn_fbs_del(buf);
1184	return;
1185	}
1186
1187	ret = main_ecnl_set(dealer->requestId, dealer, device->deviceId, dealer->ecnl_mag);
1188	if (ret == E_OK) {
1189	dealer->error = NULL;
1190	}
1191	else {
1192	_ecn_fbs_del(buf);
1193	}
1194
1195	dealer->ecnl_mag = NULL;
1196	}
1197
1198	void wamp_dealer_ecnl_set_res(struct wamp_dealer dealer, T_EDATA esv)
1199	{
1200	wamp_state_t *s = dealer->s;
1201	echonetlite_device_t *device = dealer->current_device;
1202	ECN_FBS_ID buf;
1203	ECN_FBS_SSIZE_T pos = 0, start;
1204	uint8_t epc;
1205	uint8_t pdc;
1206	uint8_t p_edt[256];
1207	T_ENUM_EPC enm;
1208	int j;
1209	ER ret;
1210
1211	if(device == NULL)
1212	return;
1213
1214	ret = _ecn_fbs_cre(1, &buf);
1215	if (ret != E_OK) {
1216	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1217	return;
1218	}
1219
1220	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":%d},[],",
1221	dealer->requestId, device->deviceId);
1222	if (ret != E_OK) {
1223	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1224	_ecn_fbs_del(buf);
1225	return;
1226	}
1227
1228	/* プロパティ値書き込み応答 0x71 */
1229	ret = fbs_printf(buf, &pos, "{\"esv\":113,\"sender\":%d,\"seoj\":\"%02x%02x%02x\",\"deoj\":\"%02x%02x%02x\",\"properties\":[",
1230	ecn_get_enod(esv), esv->hdr.edata.seoj.eojx1, esv->hdr.edata.seoj.eojx2, esv->hdr.edata.seoj.eojx3,
1231	esv->hdr.edata.deoj.eojx1, esv->hdr.edata.deoj.eojx2, esv->hdr.edata.deoj.eojx3);
1232	if (ret != E_OK) {
1233	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1234	_ecn_fbs_del(buf);
1235	return;
1236	}
1237
1238	ret = ecn_itr_ini(&enm, esv);
1239	if (ret != E_OK){
1240	syslog(LOG_ERROR, "ecn_itr_ini");
1241	return;
1242	}
1243
1244	start = pos;
1245	for(;;) {
1246	while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
1247	if (pdc == 0) {
1248	ret = fbs_printf(buf, &pos, "{\"epc\":%d},", epc);
1249	if (ret != E_OK) {
1250	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1251	_ecn_fbs_del(buf);
1252	return;
1253	}
1254	}
1255	else {
1256	ret = fbs_printf(buf, &pos, "{\"epc\":%d,\"edt\":\"", epc);
1257	if (ret != E_OK) {
1258	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1259	_ecn_fbs_del(buf);
1260	return;
1261	}
1262	for(j = 0; j < pdc; j++){
1263	ret = fbs_printf(buf, &pos, "%02x", p_edt[j]);
1264	if (ret != E_OK) {
1265	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1266	_ecn_fbs_del(buf);
1267	return;
1268	}
1269	}
1270	ret = fbs_printf(buf, &pos, "\"},");
1271	if (ret != E_OK) {
1272	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1273	_ecn_fbs_del(buf);
1274	return;
1275	}
1276	}
1277	}
1278	if(ret != E_BOVR){
1279	syslog(LOG_ERROR, "ecn_itr_nxt");
1280	break;
1281	}
1282	if(enm.is_eof)
1283	break;
1284	}
1285
1286	/* 最後の","を消す */
1287	if(start != pos)
1288	pos--;
1289
1290	ret = fbs_printf(buf, &pos, "]}]");
1291	if (ret != E_OK) {
1292	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1293	_ecn_fbs_del(buf);
1294	return;
1295	}
1296
1297	ret = main_send_message(buf, s->wbsid);
1298	if (ret != E_OK) {
1299	syslog(LOG_WARNING, "wamp_dealer_ecnl_set_res() : main_send_message() result = %d", ret);
1300	}
1301	}
1302
1303	void wamp_dealer_ecnl_set_timeout(struct wamp_dealer *dealer)
1304	{
1305	wamp_state_t *s = dealer->s;
1306	ER ret;
1307
1308	ret = wamp_send_error_res(s, WAMP_CODE_CALL, dealer->requestId, internal_error);
1309	if (ret != E_OK) {
1310	syslog(LOG_WARNING, "wamp_dealer_ecnl_set_timeout() : wamp_send_error_res() result = %d", ret);
1311	}
1312	}
1313
1314	static void wamp_dealer_ecnl_get_close(struct wamp_dealer *dealer)
1315	{
1316	ER ret;
1317	echonetlite_device_t *device = dealer->current_device;
1318	ECN_FBS_ID buf = { (T_ECN_FST_BLK *)dealer->ecnl_mag };
1319
1320	if (dealer->ecnl_mag == NULL)
1321	return;
1322
1323	if(device == NULL){
1324	_ecn_fbs_del(buf);
1325	return;
1326	}
1327
1328	ret = main_ecnl_get(dealer->requestId, dealer, device->deviceId, dealer->ecnl_mag);
1329	if (ret == E_OK) {
1330	dealer->error = NULL;
1331	}
1332	else {
1333	_ecn_fbs_del(buf);
1334	}
1335
1336	dealer->ecnl_mag = NULL;
1337	}
1338
1339	void wamp_dealer_ecnl_get_res(struct wamp_dealer dealer, T_EDATA esv)
1340	{
1341	wamp_state_t *s = dealer->s;
1342	echonetlite_device_t *device = dealer->current_device;
1343	ECN_FBS_ID buf;
1344	ECN_FBS_SSIZE_T pos = 0, start;
1345	uint8_t epc;
1346	uint8_t pdc;
1347	uint8_t p_edt[256];
1348	T_ENUM_EPC enm;
1349	int j;
1350	ER ret;
1351
1352	if(device == NULL)
1353	return;
1354
1355	ret = _ecn_fbs_cre(1, &buf);
1356	if (ret != E_OK) {
1357	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1358	return;
1359	}
1360
1361	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":%d},[],",
1362	dealer->requestId, device->deviceId);
1363	if (ret != E_OK) {
1364	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1365	_ecn_fbs_del(buf);
1366	return;
1367	}
1368
1369	/* プロパティ値読み込み応答 0x72 */
1370	ret = fbs_printf(buf, &pos, "{\"esv\":114,\"sender\":%d,\"seoj\":\"%02x%02x%02x\",\"deoj\":\"%02x%02x%02x\",\"properties\":[",
1371	ecn_get_enod(esv), esv->hdr.edata.seoj.eojx1, esv->hdr.edata.seoj.eojx2, esv->hdr.edata.seoj.eojx3,
1372	esv->hdr.edata.deoj.eojx1, esv->hdr.edata.deoj.eojx2, esv->hdr.edata.deoj.eojx3);
1373	if (ret != E_OK) {
1374	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1375	_ecn_fbs_del(buf);
1376	return;
1377	}
1378
1379	ret = ecn_itr_ini(&enm, esv);
1380	if (ret != E_OK){
1381	syslog(LOG_ERROR, "ecn_itr_ini");
1382	return;
1383	}
1384
1385	start = pos;
1386	for(;;) {
1387	while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
1388	if (pdc == 0) {
1389	ret = fbs_printf(buf, &pos, "{\"epc\":%d},", epc);
1390	if (ret != E_OK) {
1391	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1392	_ecn_fbs_del(buf);
1393	return;
1394	}
1395	}
1396	else {
1397	ret = fbs_printf(buf, &pos, "{\"epc\":%d,\"edt\":\"", epc);
1398	if (ret != E_OK) {
1399	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1400	_ecn_fbs_del(buf);
1401	return;
1402	}
1403	for(j = 0; j < pdc; j++){
1404	ret = fbs_printf(buf, &pos, "%02x", p_edt[j]);
1405	if (ret != E_OK) {
1406	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1407	_ecn_fbs_del(buf);
1408	return;
1409	}
1410	}
1411	ret = fbs_printf(buf, &pos, "\"},");
1412	if (ret != E_OK) {
1413	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1414	_ecn_fbs_del(buf);
1415	return;
1416	}
1417	}
1418	}
1419	if(ret != E_BOVR){
1420	syslog(LOG_ERROR, "ecn_itr_nxt");
1421	break;
1422	}
1423	if(enm.is_eof)
1424	break;
1425	}
1426
1427	/* 最後の","を消す */
1428	if(start != pos)
1429	pos--;
1430
1431	ret = fbs_printf(buf, &pos, "]}]");
1432	if (ret != E_OK) {
1433	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1434	_ecn_fbs_del(buf);
1435	return;
1436	}
1437
1438	ret = main_send_message(buf, s->wbsid);
1439	if (ret != E_OK) {
1440	syslog(LOG_WARNING, "wamp_dealer_ecnl_get_res() : main_send_message() result = %d", ret);
1441	}
1442	}
1443
1444	void wamp_dealer_ecnl_get_timeout(struct wamp_dealer *dealer)
1445	{
1446	wamp_state_t *s = dealer->s;
1447	ER ret;
1448
1449	ret = wamp_send_error_res(s, WAMP_CODE_CALL, dealer->requestId, internal_error);
1450	if (ret != E_OK) {
1451	syslog(LOG_WARNING, "wamp_dealer_ecnl_get_timeout() : wamp_send_error_res() result = %d", ret);
1452	}
1453	}
1454
1455	static void wamp_dealer_ecnl_setget_close(struct wamp_dealer *dealer)
1456	{
1457	ER ret;
1458	echonetlite_device_t *device = dealer->current_device;
1459	ECN_FBS_ID buf = { (T_ECN_FST_BLK *)dealer->ecnl_mag };
1460
1461	if (dealer->ecnl_mag == NULL)
1462	return;
1463
1464	if(device == NULL){
1465	_ecn_fbs_del(buf);
1466	return;
1467	}
1468
1469	ret = main_ecnl_setget(dealer->requestId, dealer, device->deviceId, dealer->ecnl_mag);
1470	if (ret == E_OK) {
1471	dealer->error = NULL;
1472	}
1473	else {
1474	_ecn_fbs_del(buf);
1475	}
1476
1477	dealer->ecnl_mag = NULL;
1478	}
1479
1480	void wamp_dealer_ecnl_setget_res(struct wamp_dealer dealer, T_EDATA esv)
1481	{
1482	wamp_state_t *s = dealer->s;
1483	echonetlite_device_t *device = dealer->current_device;
1484	ECN_FBS_ID buf;
1485	ECN_FBS_SSIZE_T pos = 0, start;
1486	uint8_t epc;
1487	uint8_t pdc;
1488	uint8_t p_edt[256];
1489	T_ENUM_EPC enm;
1490	int j;
1491	ER ret;
1492
1493	if(device == NULL)
1494	return;
1495
1496	ret = _ecn_fbs_cre(1, &buf);
1497	if (ret != E_OK) {
1498	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1499	return;
1500	}
1501
1502	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":%d},[],",
1503	dealer->requestId, device->deviceId);
1504	if (ret != E_OK) {
1505	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1506	_ecn_fbs_del(buf);
1507	return;
1508	}
1509
1510	/* プロパティ値書き込み・読み込み応答 0x7E */
1511	ret = fbs_printf(buf, &pos, "{\"esv\":126,\"sender\":%d,\"seoj\":\"%02x%02x%02x\",\"deoj\":\"%02x%02x%02x\",\"properties\":[",
1512	ecn_get_enod(esv), esv->hdr.edata.seoj.eojx1, esv->hdr.edata.seoj.eojx2, esv->hdr.edata.seoj.eojx3,
1513	esv->hdr.edata.deoj.eojx1, esv->hdr.edata.deoj.eojx2, esv->hdr.edata.deoj.eojx3);
1514	if (ret != E_OK) {
1515	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1516	_ecn_fbs_del(buf);
1517	return;
1518	}
1519
1520	ret = ecn_itr_ini(&enm, esv);
1521	if (ret != E_OK){
1522	syslog(LOG_ERROR, "ecn_itr_ini");
1523	return;
1524	}
1525
1526	start = pos;
1527	for(;;) {
1528	while ((ret = ecn_itr_nxt(&enm, &epc, &pdc, p_edt)) == E_OK) {
1529	if (pdc == 0) {
1530	ret = fbs_printf(buf, &pos, "{\"epc\":%d},", epc);
1531	if (ret != E_OK) {
1532	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1533	_ecn_fbs_del(buf);
1534	return;
1535	}
1536	}
1537	else {
1538	ret = fbs_printf(buf, &pos, "{\"epc\":%d,\"edt\":\"", epc);
1539	if (ret != E_OK) {
1540	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1541	_ecn_fbs_del(buf);
1542	return;
1543	}
1544	for(j = 0; j < pdc; j++){
1545	ret = fbs_printf(buf, &pos, "%02x", p_edt[j]);
1546	if (ret != E_OK) {
1547	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1548	_ecn_fbs_del(buf);
1549	return;
1550	}
1551	}
1552	ret = fbs_printf(buf, &pos, "\"},");
1553	if (ret != E_OK) {
1554	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1555	_ecn_fbs_del(buf);
1556	return;
1557	}
1558	}
1559	}
1560	if(ret != E_BOVR){
1561	syslog(LOG_ERROR, "ecn_itr_nxt");
1562	break;
1563	}
1564	if(enm.is_eof)
1565	break;
1566	}
1567
1568	/* 最後の","を消す */
1569	if(start != pos)
1570	pos--;
1571
1572	ret = fbs_printf(buf, &pos, "]}]");
1573	if (ret != E_OK) {
1574	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1575	_ecn_fbs_del(buf);
1576	return;
1577	}
1578
1579	ret = main_send_message(buf, s->wbsid);
1580	if (ret != E_OK) {
1581	syslog(LOG_WARNING, "wamp_dealer_ecnl_setget_res() : main_send_message() result = %d", ret);
1582	}
1583	}
1584
1585	void wamp_dealer_ecnl_setget_timeout(struct wamp_dealer *dealer)
1586	{
1587	wamp_state_t *s = dealer->s;
1588	ER ret;
1589
1590	ret = wamp_send_error_res(s, WAMP_CODE_CALL, dealer->requestId, internal_error);
1591	if (ret != E_OK) {
1592	syslog(LOG_WARNING, "wamp_dealer_ecnl_setget_timeout() : wamp_send_error_res() result = %d", ret);
1593	}
1594	}
1595
1596	static void wamp_dealer_pin_mode_close(struct wamp_dealer *dealer)
1597	{
1598	wamp_state_t *s = dealer->s;
1599	ECN_FBS_ID buf;
1600	ECN_FBS_SSIZE_T pos = 0;
1601	ER ret = E_PAR;
1602
1603	switch(dealer->arduino_params.mode){
1604	case WAMP_DEALER_PIN_MODE_INPUT:
1605	ret = arduino_pinMode(dealer->arduino_params.pin, ARDUINO_PIN_MODE_INPUT);
1606	break;
1607	case WAMP_DEALER_PIN_MODE_OUTPUT:
1608	ret = arduino_pinMode(dealer->arduino_params.pin, ARDUINO_PIN_MODE_OUTPUT);
1609	break;
1610	case WAMP_DEALER_PIN_MODE_INPUT_PULLUP:
1611	ret = arduino_pinMode(dealer->arduino_params.pin, ARDUINO_PIN_MODE_INPUT_PULLUP);
1612	break;
1613	}
1614
1615	if (ret != E_OK)
1616	return;
1617
1618	ret = _ecn_fbs_cre(1, &buf);
1619	if (ret != E_OK) {
1620	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1621	return;
1622	}
1623
1624	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":1},[],{}]", dealer->requestId);
1625	if (ret != E_OK) {
1626	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1627	_ecn_fbs_del(buf);
1628	return;
1629	}
1630
1631	ret = main_send_message(buf, s->wbsid);
1632	if (ret != E_OK) {
1633	syslog(LOG_WARNING, "main_send_message() result = %d", ret);
1634	return;
1635	}
1636
1637	dealer->error = NULL;
1638	}
1639
1640	static void wamp_dealer_digital_write_close(struct wamp_dealer *dealer)
1641	{
1642	wamp_state_t *s = dealer->s;
1643	ECN_FBS_ID buf;
1644	ECN_FBS_SSIZE_T pos = 0;
1645	ER ret = E_PAR;
1646
1647	switch(dealer->arduino_params.digval){
1648	case WAMP_DEALER_DIGITAL_VALUE_HIGH:
1649	ret = arduino_digitalWrite(dealer->arduino_params.pin, ARDUINO_DIGITAL_VALUE_HIGH);
1650	break;
1651	case WAMP_DEALER_DIGITAL_VALUE_LOW:
1652	ret = arduino_digitalWrite(dealer->arduino_params.pin, ARDUINO_DIGITAL_VALUE_LOW);
1653	break;
1654	}
1655
1656	if (ret != E_OK)
1657	return;
1658
1659	ret = _ecn_fbs_cre(1, &buf);
1660	if (ret != E_OK) {
1661	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1662	return;
1663	}
1664
1665	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":1},[],{}]", dealer->requestId);
1666	if (ret != E_OK) {
1667	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1668	_ecn_fbs_del(buf);
1669	return;
1670	}
1671
1672	ret = main_send_message(buf, s->wbsid);
1673	if (ret != E_OK) {
1674	syslog(LOG_WARNING, "main_send_message() result = %d", ret);
1675	return;
1676	}
1677
1678	dealer->error = NULL;
1679	}
1680
1681	static void wamp_dealer_digital_read_close(struct wamp_dealer *dealer)
1682	{
1683	const static char *values[] = { "", "HIGH", "LOW" };
1684	wamp_state_t *s = dealer->s;
1685	ECN_FBS_ID buf;
1686	ECN_FBS_SSIZE_T pos = 0;
1687	arduino_digital_value_t value;
1688	ER ret;
1689
1690	ret = arduino_digitalRead(dealer->arduino_params.pin, &value);
1691	if (ret != E_OK)
1692	return;
1693
1694	ret = _ecn_fbs_cre(1, &buf);
1695	if (ret != E_OK) {
1696	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1697	return;
1698	}
1699
1700	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":1},[],{", dealer->requestId);
1701	if (ret != E_OK) {
1702	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1703	_ecn_fbs_del(buf);
1704	return;
1705	}
1706
1707	ret = fbs_printf(buf, &pos, "\"pin\":%d,\"value\":\"%s\"",
1708	dealer->arduino_params.pin, values[value]);
1709	if (ret != E_OK) {
1710	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1711	_ecn_fbs_del(buf);
1712	return;
1713	}
1714
1715	ret = fbs_printf(buf, &pos, "}]");
1716	if (ret != E_OK) {
1717	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1718	_ecn_fbs_del(buf);
1719	return;
1720	}
1721
1722	ret = main_send_message(buf, s->wbsid);
1723	if (ret != E_OK) {
1724	syslog(LOG_WARNING, "main_send_message() result = %d", ret);
1725	return;
1726	}
1727
1728	dealer->error = NULL;
1729	}
1730
1731	static void wamp_dealer_analog_read_close(struct wamp_dealer *dealer)
1732	{
1733	wamp_state_t *s = dealer->s;
1734	ECN_FBS_ID buf;
1735	ECN_FBS_SSIZE_T pos = 0;
1736	int value;
1737	ER ret;
1738
1739	ret = arduino_analogRead(dealer->arduino_params.pin, &value);
1740	if (ret != E_OK)
1741	return;
1742
1743	ret = _ecn_fbs_cre(1, &buf);
1744	if (ret != E_OK) {
1745	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1746	return;
1747	}
1748
1749	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":1},[],{", dealer->requestId);
1750	if (ret != E_OK) {
1751	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1752	_ecn_fbs_del(buf);
1753	return;
1754	}
1755
1756	ret = fbs_printf(buf, &pos, "\"pin\":%d,\"value\":%d",
1757	dealer->arduino_params.pin, value);
1758	if (ret != E_OK) {
1759	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1760	_ecn_fbs_del(buf);
1761	return;
1762	}
1763
1764	ret = fbs_printf(buf, &pos, "}]");
1765	if (ret != E_OK) {
1766	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1767	_ecn_fbs_del(buf);
1768	return;
1769	}
1770
1771	ret = main_send_message(buf, s->wbsid);
1772	if (ret != E_OK) {
1773	syslog(LOG_WARNING, "main_send_message() result = %d", ret);
1774	return;
1775	}
1776
1777	dealer->error = NULL;
1778	}
1779
1780	static void wamp_dealer_analog_write_close(struct wamp_dealer *dealer)
1781	{
1782	wamp_state_t *s = dealer->s;
1783	ECN_FBS_ID buf;
1784	ECN_FBS_SSIZE_T pos = 0;
1785	ER ret;
1786
1787	ret = arduino_analogWrite(dealer->arduino_params.pin, dealer->arduino_params.anaval);
1788	if (ret != E_OK)
1789	return;
1790
1791	ret = _ecn_fbs_cre(1, &buf);
1792	if (ret != E_OK) {
1793	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1794	return;
1795	}
1796
1797	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":1},[],{}]", dealer->requestId);
1798	if (ret != E_OK) {
1799	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1800	_ecn_fbs_del(buf);
1801	return;
1802	}
1803
1804	ret = main_send_message(buf, s->wbsid);
1805	if (ret != E_OK) {
1806	syslog(LOG_WARNING, "main_send_message() result = %d", ret);
1807	return;
1808	}
1809
1810	dealer->error = NULL;
1811	}
1812
1813	static void wamp_dealer_set_init_params_close(struct wamp_dealer *dealer)
1814	{
1815	wamp_state_t *s = dealer->s;
1816	ECN_FBS_ID buf;
1817	ECN_FBS_SSIZE_T pos = 0;
1818	ER ret;
1819	uint8_t data[32];
1820
1821	memset(data, 0, sizeof(data));
1822	memcpy(&data[0], dealer->init_params.mac_addr, sizeof(dealer->init_params.mac_addr));
1823	data[6] = dealer->init_params.dhcp_enable ? 1 : 0;
1824	memcpy(&data[7], dealer->init_params.ip_addr, sizeof(dealer->init_params.ip_addr));
1825	memcpy(&data[11], dealer->init_params.netmask, sizeof(dealer->init_params.netmask));
1826	memcpy(&data[15], dealer->init_params.gateway, sizeof(dealer->init_params.gateway));
1827
1828	ret = data_flash_write(0, data);
1829	if (ret != E_OK) {
1830	syslog(LOG_WARNING, "data_flash_write() result = %d", ret);
1831	return;
1832	}
1833
1834	ret = _ecn_fbs_cre(1, &buf);
1835	if (ret != E_OK) {
1836	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1837	return;
1838	}
1839
1840	ret = fbs_printf(buf, &pos, "[50,%d,{\"deviceId\":1},[],{}]", dealer->requestId);
1841	if (ret != E_OK) {
1842	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1843	_ecn_fbs_del(buf);
1844	return;
1845	}
1846
1847	ret = main_send_message(buf, s->wbsid);
1848	if (ret != E_OK) {
1849	syslog(LOG_WARNING, "main_send_message() result = %d", ret);
1850	return;
1851	}
1852
1853	dealer->error = NULL;
1854	}
1855
1856	static ER wamp_dealer_write_ip_addr(struct wamp_dealer *dealer, ECN_FBS_ID buf,
1857	ECN_FBS_SSIZE_T pos, uint8_t ip_addr, char *name)
1858	{
1859	ER ret;
1860	int i;
1861
1862	/* IPアドレス */
1863	ret = fbs_printf(buf, pos, "\"%s\":[", name);
1864	if (ret != E_OK) {
1865	return ret;
1866	}
1867
1868	for (i = 0; i < 4; i++) {
1869	ret = fbs_printf(buf, pos, "%d,", ip_addr[i]);
1870	if (ret != E_OK) {
1871	return ret;
1872	}
1873	}
1874
1875	/* 最後の","を消す */
1876	pos = pos - 1;
1877
1878	ret = fbs_printf(buf, pos, "],");
1879	if (ret != E_OK) {
1880	return ret;
1881	}
1882
1883	return E_OK;
1884	}
1885
1886	static void wamp_dealer_get_init_params_close(struct wamp_dealer *dealer)
1887	{
1888	wamp_state_t *s = dealer->s;
1889	ECN_FBS_ID buf;
1890	ECN_FBS_SSIZE_T pos = 0;
1891	ER ret;
1892	int i;
1893	uint8_t data[32];
1894
1895	ret = data_flash_read(0, data);
1896	if (ret != E_OK) {
1897	syslog(LOG_WARNING, "data_flash_read() result = %d", ret);
1898	return;
1899	}
1900
1901	memcpy(dealer->init_params.mac_addr, &data[0], sizeof(dealer->init_params.mac_addr));
1902	dealer->init_params.dhcp_enable = data[6] != 0;
1903	memcpy(dealer->init_params.ip_addr, &data[7], sizeof(dealer->init_params.ip_addr));
1904	memcpy(dealer->init_params.netmask, &data[11], sizeof(dealer->init_params.netmask));
1905	memcpy(dealer->init_params.gateway, &data[15], sizeof(dealer->init_params.gateway));
1906
1907	ret = _ecn_fbs_cre(1, &buf);
1908	if (ret != E_OK) {
1909	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
1910	return;
1911	}
1912
1913	ret = fbs_printf(buf, &pos, "[50,%d,{},[],{", dealer->requestId);
1914	if (ret != E_OK) {
1915	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1916	_ecn_fbs_del(buf);
1917	return;
1918	}
1919
1920	/* MACアドレス */
1921	ret = fbs_printf(buf, &pos, "\"macAddr\":[");
1922	if (ret != E_OK) {
1923	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1924	_ecn_fbs_del(buf);
1925	return;
1926	}
1927
1928	for (i = 0; i < 6; i++) {
1929	ret = fbs_printf(buf, &pos, "%d,", dealer->init_params.mac_addr[i]);
1930	if (ret != E_OK) {
1931	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1932	_ecn_fbs_del(buf);
1933	return;
1934	}
1935	}
1936
1937	/* 最後の","を消す */
1938	pos--;
1939
1940	ret = fbs_printf(buf, &pos, "],");
1941	if (ret != E_OK) {
1942	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1943	_ecn_fbs_del(buf);
1944	return;
1945	}
1946
1947	/* DHCP有効／無効 */
1948	ret = fbs_printf(buf, &pos, "\"dhcpEnable\":%s,", dealer->init_params.dhcp_enable ? "true" : "false");
1949	if (ret != E_OK) {
1950	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1951	_ecn_fbs_del(buf);
1952	return;
1953	}
1954
1955	/* IPアドレス */
1956	ret = wamp_dealer_write_ip_addr(dealer, buf, &pos, dealer->init_params.ip_addr, "ipAddr");
1957	if (ret != E_OK) {
1958	syslog(LOG_WARNING, "wamp_dealer_write_ip_addr() result = %d", ret);
1959	_ecn_fbs_del(buf);
1960	return;
1961	}
1962
1963	/* サブネットマスク */
1964	ret = wamp_dealer_write_ip_addr(dealer, buf, &pos, dealer->init_params.netmask, "netmask");
1965	if (ret != E_OK) {
1966	syslog(LOG_WARNING, "wamp_dealer_write_ip_addr() result = %d", ret);
1967	_ecn_fbs_del(buf);
1968	return;
1969	}
1970
1971	/* デフォルトゲートウェイ */
1972	ret = wamp_dealer_write_ip_addr(dealer, buf, &pos, dealer->init_params.gateway, "gateway");
1973	if (ret != E_OK) {
1974	syslog(LOG_WARNING, "wamp_dealer_write_ip_addr() result = %d", ret);
1975	_ecn_fbs_del(buf);
1976	return;
1977	}
1978
1979	/* 最後の","を消す */
1980	pos--;
1981
1982	ret = fbs_printf(buf, &pos, "}]");
1983	if (ret != E_OK) {
1984	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
1985	_ecn_fbs_del(buf);
1986	return;
1987	}
1988
1989	ret = main_send_message(buf, s->wbsid);
1990	if (ret != E_OK) {
1991	syslog(LOG_WARNING, "main_send_message() result = %d", ret);
1992	return;
1993	}
1994
1995	dealer->error = NULL;
1996	}
1997
1998	void wamp_dealer_yield(wamp_dealer_t *dealer)
1999	{
2000	}
2001
2002	void wamp_dealer_yield_request_id(wamp_dealer_t dealer, const char value)
2003	{
2004	}
2005
2006	void wamp_dealer_yield_options(wamp_dealer_t dealer, const char value)
2007	{
2008	}
2009
2010	void wamp_dealer_yield_options_param(wamp_dealer_t *dealer, jsonsl_action_t action,
2011	struct jsonsl_state_st state, const char buf)
2012	{
2013	}
2014
2015	void wamp_dealer_yield_arguments(wamp_dealer_t dealer, const char value)
2016	{
2017	}
2018
2019	void wamp_dealer_yield_arguments_param(wamp_dealer_t *dealer, jsonsl_action_t action,
2020	struct jsonsl_state_st state, const char buf)
2021	{
2022	}
2023
2024	void wamp_dealer_yield_argumentskw(wamp_dealer_t dealer, const char value)
2025	{
2026	}
2027
2028	void wamp_dealer_yield_argumentskw_param(wamp_dealer_t *dealer, jsonsl_action_t action,
2029	struct jsonsl_state_st state, const char buf)
2030	{
2031	}
2032
2033	void wamp_dealer_yield_close(struct wamp_state *s)
2034	{
2035	}
2036
2037	void wamp_dealer_cansel(wamp_dealer_t *dealer)
2038	{
2039	}
2040
2041	void wamp_dealer_cansel_request_id(wamp_dealer_t dealer, const char value)
2042	{
2043	}
2044
2045	void wamp_dealer_cansel_options(wamp_dealer_t dealer, const char value)
2046	{
2047	}
2048
2049	void wamp_dealer_cansel_options_param(wamp_dealer_t *dealer, jsonsl_action_t action,
2050	struct jsonsl_state_st state, const char buf)
2051	{
2052	}
2053
2054	void wamp_dealer_cansel_close(struct wamp_state *s)
2055	{
2056	}
2057
2058	static bool_t wamp_dealer_get_epc(const char *propName, int nameLen,
2059	uint16_t devType, uint8_t epc, uint8_t pdc)
2060	{
2061	if(propName[0] == '0' && propName[1] == 'x'){
2062	if((wamp_stob(&propName[2], epc, sizeof(*epc)) != 1)
2063	\|\| (propName[4] != '\0')){
2064	*epc = 0;
2065	*pdc = 0;
2066	return false;
2067	}
2068
2069	*pdc = 1;
2070	return true;
2071	}
2072
2073	*epc = kadecot_names_get_property_code(propName, nameLen, devType);
2074	if(*epc == 0){
2075	*pdc = 0;
2076	return false;
2077	}
2078	*pdc = 1;
2079
2080	return true;
2081	}
2082
2083	static echonetlite_device_t wamp_dealer_get_device(wamp_dealer_t dealer, int deviceId)
2084	{
2085	echonetlite_device_t pos, end = &dealer->devices[sizeof(dealer->devices) / sizeof(dealer->devices[0])];
2086
2087	if(deviceId <= 0)
2088	return NULL;
2089
2090	for(pos = dealer->devices; pos < end; pos++){
2091	if(pos->deviceId != deviceId)
2092	continue;
2093
2094	return pos;
2095	}
2096
2097	return NULL;
2098	}
2099
2100	int wamp_stob(const char str, uint8_t dst, int dstc)
2101	{
2102	uint8_t start = dst, end = &dst[dstc];
2103	int size = 0, i;
2104	char c;
2105	uint8_t data;
2106
2107	for(i = 0; dst < end; dst++){
2108	c = str[i];
2109	if(c == '\0')
2110	break;
2111
2112	data = 0;
2113
2114	if(c >= '0' && c <= '9'){
2115	data \|= (c - '0');
2116	}
2117	else if(c >= 'A' && c <= 'F'){
2118	data \|= (0xA + c - 'A');
2119	}
2120	else if(c >= 'a' && c <= 'f'){
2121	data \|= (0xA + c - 'a');
2122	}
2123	else
2124	break;
2125
2126	i++;
2127	c = str[i];
2128	data <<= 4;
2129
2130	if(c >= '0' && c <= '9'){
2131	data \|= (c - '0');
2132	}
2133	else if(c >= 'A' && c <= 'F'){
2134	data \|= (0xA + c - 'A');
2135	}
2136	else if(c >= 'a' && c <= 'f'){
2137	data \|= (0xA + c - 'a');
2138	}
2139	else
2140	break;
2141
2142	i++;
2143	*dst = data;
2144	}
2145
2146	return dst - start;
2147	}
2148
2149	void wamp_dealer_init(wamp_dealer_t *dealer)
2150	{
2151	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: