Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

wamp.c@ 101

Last change on this file since 101 was 101, checked in by coas-nagasima, 9 years ago
TOPPERS/uKadecotのソースコードを追加
Property svn:eol-style set to `native` Property svn:keywords set to `Id` Property svn:mime-type set to `text/plain`
File size: 56.7 KB

Rev	Line
[101]	1	/*
	2	* TOPPERS ECHONET Lite Communication Middleware
	3	*
	4	* Copyright (C) 2015 Cores Co., Ltd. Japan
	5	*
	6	* ãLì ÒÍCÈºÌ(1)`(4)Ìðð½·êÉÀèC{\tgEF
	7	* Ai{\tgEFAðüÏµ½àÌðÜÞDÈº¯¶jðgpE¡»Eü
	8	* ÏEÄzziÈºCpÆÄÔj·é±Æð³Åø·éD
	9	* (1) {\tgEFAð\[XR[hÌ`Åp·éêÉÍCãLÌì
	10	* \¦C±Ìpð¨æÑºLÌ³ÛØKèªC»ÌÜÜÌ`Å\[
	11	* XR[hÉÜÜêÄ¢é±ÆD
	12	* (2) {\tgEFAðCCu`®ÈÇC¼Ì\tgEFAJÉg
	13	* pÅ«é`ÅÄzz·éêÉÍCÄzzÉº¤hL
	14	gip
	15	* Ò}j
	16	AÈÇjÉCãLÌì \¦C±Ìpð¨æÑºL
	17	* Ì³ÛØKèðfÚ·é±ÆD
	18	* (3) {\tgEFAðC@íÉgÝÞÈÇC¼Ì\tgEFAJÉg
	19	* pÅ«È¢`ÅÄzz·éêÉÍCÌ¢¸ê©Ìðð½·±
	20	* ÆD
	21	* (a) ÄzzÉº¤hL
	22	gipÒ}j
	23	AÈÇjÉCãLÌ
	24	* ì \¦C±Ìpð¨æÑºLÌ³ÛØKèðfÚ·é±ÆD
	25	* (b) ÄzzÌ`ÔðCÊÉèßéû@ÉæÁÄCTOPPERSvWFNgÉ
	26	* ñ·é±ÆD
	27	* (4) {\tgEFAÌpÉæè¼ÚIÜ½ÍÔÚIÉ¶¶é¢©Èé¹
	28	* Q©çàCãLì Ò¨æÑTOPPERSvWFNgðÆÓ·é±ÆD
	29	* Ü½C{\tgEFAÌ[UÜ½ÍGh[U©çÌ¢©Èé
	30	* RÉîÃ¿©çàCãLì Ò¨æÑTOPPERSvWFNgð
	31	* ÆÓ·é±ÆD
	32	*
	33	* {\tgEFAÍC³ÛØÅñ³êÄ¢éàÌÅ éDãLì Ò¨
	34	* æÑTOPPERSvWFNgÍC{\tgEFAÉÖµÄCÁèÌgpÚI
	35	* ÉÎ·éK«àÜßÄC¢©ÈéÛØàsíÈ¢DÜ½C{\tgEF
	36	* AÌpÉæè¼ÚIÜ½ÍÔÚIÉ¶¶½¢©Èé¹QÉÖµÄàC»
	37	* ÌÓCðíÈ¢D
	38	*
	39	* @(#) $Id: wamp.c 101 2015-06-02 15:37:23Z coas-nagasima $
	40	*/
	41
	42	#include <string.h>
	43	#include "wamp.h"
	44	#include "kernel_cfg.h"
	45	#include "fbs_string.h"
	46	#include "main.h"
	47
	48	/* p[XG[iè`ÌÝj */
	49	const char parse_error[] = "com.sonycsl.kadecot.plugin.echonetlite.error.parse_error";
	50	/* ³øÈNGXgiè`ÌÝj */
	51	const char invalid_request[] = "com.sonycsl.kadecot.plugin.echonetlite.error.invalid_request";
	52	/* ¶ÝµÈ¢\bhiè`ÌÝj */
	53	const char method_not_found[] = "com.sonycsl.kadecot.plugin.echonetlite.error.method_not_found";
	54	/* echo objectª¶ÝµÈ¢,@JSONArray`®ÉÈÁÄ¢È¢ */
	55	const char invalid_params[] = "com.sonycsl.kadecot.plugin.echonetlite.error.invalid_params";
	56	/* ^CAEg¶, R[obNª@null*/
	57	const char internal_error[] = "com.sonycsl.kadecot.plugin.echonetlite.error.internal_error";
	58
	59	static void wamp_idle_parse_state(wamp_state_t *s, jsonsl_action_t action,
	60	struct jsonsl_state_st state, const char buf);
	61	static void wamp_code_push_parse_state(wamp_state_t *s, jsonsl_action_t action,
	62	struct jsonsl_state_st state, const char buf);
	63	static void wamp_code_pop_parse_state(wamp_state_t *s, jsonsl_action_t action,
	64	struct jsonsl_state_st state, const char buf);
	65	static void wamp_param_parse_state(wamp_state_t *s, jsonsl_action_t action,
	66	struct jsonsl_state_st state, const char buf);
	67	static void wamp_nomore_param_parse_state(wamp_state_t *s, jsonsl_action_t action,
	68	struct jsonsl_state_st state, const char buf);
	69	static void wamp_id_parse_state(wamp_state_t *s, jsonsl_action_t action,
	70	struct jsonsl_state_st state, const char buf);
	71	static void wamp_list_parse_state(wamp_state_t *s, jsonsl_action_t action,
	72	struct jsonsl_state_st state, const char buf);
	73	static void wamp_dict_parse_state(wamp_state_t *s, jsonsl_action_t action,
	74	struct jsonsl_state_st state, const char buf);
	75	static void wamp_uri_parse_state(wamp_state_t *s, jsonsl_action_t action,
	76	struct jsonsl_state_st state, const char buf);
	77	static void wamp_int_parse_state(wamp_state_t *s, jsonsl_action_t action,
	78	struct jsonsl_state_st state, const char buf);
	79	static void wamp_string_parse_state(wamp_state_t *s, jsonsl_action_t action,
	80	struct jsonsl_state_st state, const char buf);
	81
	82	static void wamp_proc_hello_state(wamp_state_t *s, jsonsl_action_t action,
	83	struct jsonsl_state_st state, const char buf);
	84	static void wamp_proc_welcome_state(wamp_state_t *s, jsonsl_action_t action,
	85	struct jsonsl_state_st state, const char buf);
	86	static void wamp_proc_abort_state(wamp_state_t *s, jsonsl_action_t action,
	87	struct jsonsl_state_st state, const char buf);
	88	static void wamp_proc_challenge_state(wamp_state_t *s, jsonsl_action_t action,
	89	struct jsonsl_state_st state, const char buf);
	90	static void wamp_proc_authenticate_state(wamp_state_t *s, jsonsl_action_t action,
	91	struct jsonsl_state_st state, const char buf);
	92	static void wamp_proc_goodbye_state(wamp_state_t *s, jsonsl_action_t action,
	93	struct jsonsl_state_st state, const char buf);
	94	static void wamp_proc_error_state(wamp_state_t *s, jsonsl_action_t action,
	95	struct jsonsl_state_st state, const char buf);
	96	static void wamp_proc_publish_state(wamp_state_t *s, jsonsl_action_t action,
	97	struct jsonsl_state_st state, const char buf);
	98	static void wamp_proc_published_state(wamp_state_t *s, jsonsl_action_t action,
	99	struct jsonsl_state_st state, const char buf);
	100	static void wamp_proc_subscribe_state(wamp_state_t *s, jsonsl_action_t action,
	101	struct jsonsl_state_st state, const char buf);
	102	static void wamp_proc_subscribed_state(wamp_state_t *s, jsonsl_action_t action,
	103	struct jsonsl_state_st state, const char buf);
	104	static void wamp_proc_unsubscribe_state(wamp_state_t *s, jsonsl_action_t action,
	105	struct jsonsl_state_st state, const char buf);
	106	static void wamp_proc_unsubscribed_state(wamp_state_t *s, jsonsl_action_t action,
	107	struct jsonsl_state_st state, const char buf);
	108	static void wamp_proc_event_state(wamp_state_t *s, jsonsl_action_t action,
	109	struct jsonsl_state_st state, const char buf);
	110	static void wamp_proc_call_state(wamp_state_t *s, jsonsl_action_t action,
	111	struct jsonsl_state_st state, const char buf);
	112	static void wamp_proc_cancel_state(wamp_state_t *s, jsonsl_action_t action,
	113	struct jsonsl_state_st state, const char buf);
	114	static void wamp_proc_result_state(wamp_state_t *s, jsonsl_action_t action,
	115	struct jsonsl_state_st state, const char buf);
	116	static void wamp_proc_register_state(wamp_state_t *s, jsonsl_action_t action,
	117	struct jsonsl_state_st state, const char buf);
	118	static void wamp_proc_registered_state(wamp_state_t *s, jsonsl_action_t action,
	119	struct jsonsl_state_st state, const char buf);
	120	static void wamp_proc_unregister_state(wamp_state_t *s, jsonsl_action_t action,
	121	struct jsonsl_state_st state, const char buf);
	122	static void wamp_proc_unregistered_state(wamp_state_t *s, jsonsl_action_t action,
	123	struct jsonsl_state_st state, const char buf);
	124	static void wamp_proc_invocation_state(wamp_state_t *s, jsonsl_action_t action,
	125	struct jsonsl_state_st state, const char buf);
	126	static void wamp_proc_interrupt_state(wamp_state_t *s, jsonsl_action_t action,
	127	struct jsonsl_state_st state, const char buf);
	128	static void wamp_proc_yield_state(wamp_state_t *s, jsonsl_action_t action,
	129	struct jsonsl_state_st state, const char buf);
	130
	131	static void wamp_param_handler(struct wamp_state *s, jsonsl_action_t action,
	132	wamp_param_state_t param, const char *value);
	133
	134	void wamp_error(wamp_state_t *s);
	135	void wamp_error_type(wamp_state_t s, const char value);
	136	void wamp_error_request_id(wamp_state_t s, const char value);
	137	void wamp_error_details(wamp_state_t s, const char value);
	138	void wamp_error_details_param(wamp_state_t *s, jsonsl_action_t action,
	139	struct jsonsl_state_st state, const char buf);
	140	void wamp_error_uri(wamp_state_t s, const char value);
	141	void wamp_error_arguments(wamp_state_t s, const char value);
	142	void wamp_error_arguments_param(wamp_state_t *s, jsonsl_action_t action,
	143	struct jsonsl_state_st state, const char buf);
	144	void wamp_error_argumentskw(wamp_state_t s, const char value);
	145	void wamp_error_argumentskw_param(wamp_state_t *s, jsonsl_action_t action,
	146	struct jsonsl_state_st state, const char buf);
	147	static void wamp_error_close(wamp_state_t *s);
	148
	149	void wamp_init(wamp_state_t *s)
	150	{
	151	jsonsl_t jsn;
	152
	153	memset(s, 0, sizeof(wamp_state_t));
	154	s->jsn_buf_pos = -1;
	155
	156	jsn = jsonsl_new((jsonsl_t)&s->jsn, JSN_NLEVELS);
	157	jsn->data = s;
	158	jsn->error_callback = wamp_error_callback;
	159	jsn->action_callback = wamp_state_callback;
	160	jsonsl_enable_all_callbacks(jsn);
	161
	162	s->router.s = s;
	163	s->client.s = s;
	164	s->broker.s = s;
	165	s->dealer.s = s;
	166	s->publisher.s = s;
	167	s->subscriber.s = s;
	168	s->caller.s = s;
	169	s->callee.s = s;
	170	s->param_handler = wamp_param_handler;
	171
	172	wamp_dealer_init(&s->dealer);
	173	}
	174
	175	void wamp_put_msg(wamp_state_t *s, ECN_FBS_ID msg, ID wbsid)
	176	{
	177	ECN_FBS_SSIZE_T len, pos;
	178	uint8_t data;
	179
	180	s->wbsid = wbsid;
	181
	182	len = _ecn_fbs_get_datalen(msg);
	183
	184	for (pos = 0; pos < len; pos++) {
	185	data = _ecn_fbs_peek(msg, pos);
	186
	187	if ((s->jsn_buf_pos >= 0) && (s->jsn_buf_pos < sizeof(s->jsn_buf)))
	188	s->jsn_buf[s->jsn_buf_pos++] = data;
	189	jsonsl_feed((jsonsl_t)s->jsn, &data, 1);
	190	}
	191	}
	192
	193	void wamp_state_callback(jsonsl_t jsn, jsonsl_action_t action,
	194	struct jsonsl_state_st state, const char buf)
	195	{
	196	wamp_state_t s = (wamp_state_t )jsn->data;
	197	/*syslog(7, "@%5ld '%c' L%d %c%s",
	198	jsn->pos,
	199	*buf,
	200	state->level,
	201	action,
	202	jsonsl_strtype(state->type));*/
	203
	204	switch (action) {
	205	case JSONSL_ACTION_PUSH:
	206	switch (state->type) {
	207	case JSONSL_T_SPECIAL:
	208	s->jsn_buf[0] = *buf;
	209	s->jsn_buf_pos = 1;
	210	break;
	211	case JSONSL_T_STRING:
	212	case JSONSL_T_HKEY:
	213	s->jsn_buf_pos = 0;
	214	break;
	215	default:
	216	s->jsn_buf_pos = -1;
	217	}
	218	break;
	219	case JSONSL_ACTION_POP:
	220	switch (state->type) {
	221	case JSONSL_T_SPECIAL:
	222	case JSONSL_T_STRING:
	223	case JSONSL_T_HKEY:
	224	s->jsn_buf_pos--;
	225	if (s->jsn_buf_pos < sizeof(s->jsn_buf)) {
	226	s->jsn_buf[s->jsn_buf_pos] = '\0';
	227	}
	228	break;
	229	default:
	230	s->jsn_buf[0] = '\0';
	231	break;
	232	}
	233	s->jsn_buf_pos = -1;
	234	break;
	235	default:
	236	s->jsn_buf_pos = -1;
	237	break;
	238	}
	239
	240	switch (s->state) {
	241	case WAMP_PARSE_STATE_IDLE:
	242	wamp_idle_parse_state(s, action, state, buf);
	243	break;
	244	case WAMP_PARSE_STATE_CODE_PUSH:
	245	wamp_code_push_parse_state(s, action, state, buf);
	246	break;
	247	case WAMP_PARSE_STATE_CODE_POP:
	248	wamp_code_pop_parse_state(s, action, state, buf);
	249	break;
	250	case WAMP_PARSE_STATE_ID_PUSH:
	251	wamp_id_parse_state(s, action, state, buf);
	252	break;
	253	case WAMP_PARSE_STATE_LIST_PUSH:
	254	wamp_list_parse_state(s, action, state, buf);
	255	break;
	256	case WAMP_PARSE_STATE_DICT_PUSH:
	257	wamp_dict_parse_state(s, action, state, buf);
	258	break;
	259	case WAMP_PARSE_STATE_URI_PUSH:
	260	wamp_uri_parse_state(s, action, state, buf);
	261	break;
	262	case WAMP_PARSE_STATE_INT_PUSH:
	263	wamp_int_parse_state(s, action, state, buf);
	264	break;
	265	case WAMP_PARSE_STATE_STRING_PUSH:
	266	wamp_string_parse_state(s, action, state, buf);
	267	break;
	268	case WAMP_PARSE_STATE_PARAM:
	269	wamp_param_parse_state(s, action, state, buf);
	270	break;
	271	case WAMP_PARSE_STATE_NOMORE_PARAM:
	272	wamp_nomore_param_parse_state(s, action, state, buf);
	273	break;
	274	default:
	275	s->state = WAMP_PARSE_STATE_ERROR;
	276	break;
	277	}
	278
	279	if (s->state == WAMP_PARSE_STATE_ERROR) {
	280	/* WAMPbZ[WÌÅã¾Á½ç */
	281	if ((state->level == 1) && (action == JSONSL_ACTION_POP)
	282	&& (state->type == JSONSL_T_LIST)) {
	283	s->message_close_handler(s);
	284	}
	285	else {
	286	s->param_handler(s, JSONSL_ACTION_ERROR, s->prmst, NULL);
	287	}
	288	jsonsl_reset((jsonsl_t)s->jsn);
	289	s->state = WAMP_PARSE_STATE_IDLE;
	290	}
	291	}
	292
	293	int wamp_error_callback(jsonsl_t jsn, jsonsl_error_t err,
	294	struct jsonsl_state_st state, char errat)
	295	{
	296	return 0;
	297	}
	298
	299	static void wamp_idle_parse_state(wamp_state_t *s, jsonsl_action_t action,
	300	struct jsonsl_state_st state, const char buf)
	301	{
	302	/* WAMPbZ[WÌæª¾Á½ç */
	303	if ((state->level == 1) && (action == JSONSL_ACTION_PUSH)
	304	&& (state->type == JSONSL_T_LIST)) {
	305	/* bZ[WR[hæ¾JnóÔÉÚé */
	306	s->state = WAMP_PARSE_STATE_CODE_PUSH;
	307	}
	308	}
	309
	310	static void wamp_code_push_parse_state(wamp_state_t *s, jsonsl_action_t action,
	311	struct jsonsl_state_st state, const char buf)
	312	{
	313	/* bZ[WR[hÌæ¾Jn */
	314	if ((action == JSONSL_ACTION_PUSH)
	315	&& (state->type == JSONSL_T_SPECIAL)) {
	316	/* bZ[WR[hæ¾óÔÉÚé */
	317	s->state = WAMP_PARSE_STATE_CODE_POP;
	318	}
	319	else
	320	/* bZ[WR[hªæ¾Å«È¯êÎG[ */
	321	s->state = WAMP_PARSE_STATE_ERROR;
	322	}
	323
	324	static void wamp_code_pop_parse_state(wamp_state_t *s, jsonsl_action_t action,
	325	struct jsonsl_state_st state, const char buf)
	326	{
	327	int code;
	328	wamp_parse_state_t prsst = WAMP_PARSE_STATE_ERROR;
	329
	330	/* bZ[WR[hªæ¾Å« */
	331	if ((action == JSONSL_ACTION_POP)
	332	&& (state->type == JSONSL_T_SPECIAL)) {
	333	/* bZ[WR[hðæ¾ */
	334	code = atoi(s->jsn_buf);
	335	switch (code) {
	336	/* [HELLO, Realm\|uri, Details\|dict] */
	337	case WAMP_CODE_HELLO:
	338	wamp_router_hello(&s->router);
	339	s->proc_handler = wamp_proc_hello_state;
	340	s->message_close_handler = wamp_router_hello_close;
	341	s->prmst = WAMP_PARAM_STATE_REALM_URI;
	342	prsst = WAMP_PARSE_STATE_URI_PUSH;
	343	break;
	344	/* [WELCOME, Session\|id, Details\|dict] */
	345	case WAMP_CODE_WELCOME:
	346	wamp_client_welcome(&s->client);
	347	s->proc_handler = wamp_proc_welcome_state;
	348	s->message_close_handler = wamp_client_welcome_close;
	349	s->prmst = WAMP_PARAM_STATE_SESSION_ID;
	350	prsst = WAMP_PARSE_STATE_ID_PUSH;
	351	break;
	352	/* [ABORT, Details\|dict, Reason\|uri] */
	353	case WAMP_CODE_ABORT:
	354	wamp_client_abort(&s->client);
	355	s->proc_handler = wamp_proc_abort_state;
	356	s->message_close_handler = wamp_client_abort_close;
	357	s->prmst = WAMP_PARAM_STATE_DETAILS_DICT;
	358	prsst = WAMP_PARSE_STATE_DICT_PUSH;
	359	break;
	360	/* [CHALLENGE, AuthMethod\|string, Extra\|dict] */
	361	case WAMP_CODE_CHALLENGE:
	362	wamp_client_challenge(&s->client);
	363	s->proc_handler = wamp_proc_challenge_state;
	364	s->message_close_handler = wamp_client_challenge_close;
	365	s->prmst = WAMP_PARAM_STATE_AUTHMETHOD_STRING;
	366	prsst = WAMP_PARSE_STATE_STRING_PUSH;
	367	break;
	368	/* [AUTHENTICATE, Signature\|string, Extra\|dict] */
	369	case WAMP_CODE_AUTHENTICATE:
	370	wamp_router_authenticate(&s->router);
	371	s->proc_handler = wamp_proc_authenticate_state;
	372	s->message_close_handler = wamp_router_authenticate_close;
	373	s->prmst = WAMP_PARAM_STATE_SIGNATURE_STRING;
	374	prsst = WAMP_PARSE_STATE_STRING_PUSH;
	375	break;
	376	/* [GOODBYE, Details\|dict, Reason\|uri] */
	377	case WAMP_CODE_GOODBYE:
	378	wamp_router_goodbye(&s->router);
	379	s->proc_handler = wamp_proc_goodbye_state;
	380	s->message_close_handler = wamp_router_goodbye_close;
	381	s->prmst = WAMP_PARAM_STATE_DETAILS_DICT;
	382	prsst = WAMP_PARSE_STATE_DICT_PUSH;
	383	break;
	384	/* [ERROR, REQUEST.Type\|int, REQUEST.Request\|id, Details\|dict, Error\|uri, Arguments\|list, ArgumentsKw\|dict] */
	385	case WAMP_CODE_ERROR:
	386	wamp_error(s);
	387	s->proc_handler = wamp_proc_error_state;
	388	s->message_close_handler = wamp_error_close;
	389	s->prmst = WAMP_PARAM_STATE_TYPE_INT;
	390	prsst = WAMP_PARSE_STATE_INT_PUSH;
	391	break;
	392	/* [PUBLISH, Request\|id, Options\|dict, Topic\|uri, Arguments\|list, ArgumentsKw\|dict] */
	393	case WAMP_CODE_PUBLISH:
	394	wamp_broker_publish(&s->broker);
	395	s->proc_handler = wamp_proc_publish_state;
	396	s->message_close_handler = wamp_broker_publish_close;
	397	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	398	prsst = WAMP_PARSE_STATE_ID_PUSH;
	399	break;
	400	/* [PUBLISHED, PUBLISH.Request\|id, Publication\|id] */
	401	case WAMP_CODE_PUBLISHED:
	402	wamp_publisher_published(&s->publisher);
	403	s->proc_handler = wamp_proc_published_state;
	404	s->message_close_handler = wamp_publisher_published_close;
	405	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	406	prsst = WAMP_PARSE_STATE_ID_PUSH;
	407	break;
	408	/* [SUBSCRIBE, Request\|id, Options\|dict, Topic\|uri] */
	409	case WAMP_CODE_SUBSCRIBE:
	410	wamp_broker_subscribe(&s->broker);
	411	s->proc_handler = wamp_proc_subscribe_state;
	412	s->message_close_handler = wamp_broker_subscribe_close;
	413	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	414	prsst = WAMP_PARSE_STATE_ID_PUSH;
	415	break;
	416	/* [SUBSCRIBED, SUBSCRIBE.Request\|id, Subscription\|id] */
	417	case WAMP_CODE_SUBSCRIBED:
	418	wamp_subscriber_subscribed(&s->subscriber);
	419	s->proc_handler = wamp_proc_subscribed_state;
	420	s->message_close_handler = wamp_subscriber_subscribed_close;
	421	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	422	prsst = WAMP_PARSE_STATE_ID_PUSH;
	423	break;
	424	/* [UNSUBSCRIBE, Request\|id, SUBSCRIBED.Subscription\|id] */
	425	case WAMP_CODE_UNSUBSCRIBE:
	426	wamp_broker_unsubscribe(&s->broker);
	427	s->proc_handler = wamp_proc_unsubscribe_state;
	428	s->message_close_handler = wamp_broker_unsubscribe_close;
	429	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	430	prsst = WAMP_PARSE_STATE_ID_PUSH;
	431	break;
	432	/* [UNSUBSCRIBED, UNSUBSCRIBE.Request\|id] */
	433	case WAMP_CODE_UNSUBSCRIBED:
	434	wamp_subscriber_unsubscribed(&s->subscriber);
	435	s->proc_handler = wamp_proc_unsubscribed_state;
	436	s->message_close_handler = wamp_subscriber_unsubscribed_close;
	437	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	438	prsst = WAMP_PARSE_STATE_ID_PUSH;
	439	break;
	440	/* [EVENT, SUBSCRIBED.Subscription\|id, PUBLISHED.Publication\|id, Details\|dict, PUBLISH.Arguments\|list, PUBLISH.ArgumentsKw\|dict] */
	441	case WAMP_CODE_EVENT:
	442	wamp_subscriber_event(&s->subscriber);
	443	s->proc_handler = wamp_proc_event_state;
	444	s->message_close_handler = wamp_subscriber_event_close;
	445	s->prmst = WAMP_PARAM_STATE_SUBSCRIPTION_ID;
	446	prsst = WAMP_PARSE_STATE_ID_PUSH;
	447	break;
	448	/* [CALL, Request\|id, Options\|dict, Procedure\|uri, Arguments\|list, ArgumentsKw\|dict] */
	449	case WAMP_CODE_CALL:
	450	wamp_dealer_call(&s->dealer);
	451	s->proc_handler = wamp_proc_call_state;
	452	s->message_close_handler = wamp_dealer_call_close;
	453	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	454	prsst = WAMP_PARSE_STATE_ID_PUSH;
	455	break;
	456	/* [CANCEL, CALL.Request\|id, Options\|dict] */
	457	case WAMP_CODE_CANCEL:
	458	wamp_dealer_cansel(&s->dealer);
	459	s->proc_handler = wamp_proc_cancel_state;
	460	s->message_close_handler = wamp_dealer_cansel_close;
	461	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	462	prsst = WAMP_PARSE_STATE_ID_PUSH;
	463	break;
	464	/* [RESULT, CALL.Request\|id, Details\|dict, YIELD.Arguments\|list, YIELD.ArgumentsKw\|dict] */
	465	case WAMP_CODE_RESULT:
	466	wamp_caller_result(&s->caller);
	467	s->proc_handler = wamp_proc_result_state;
	468	s->message_close_handler = wamp_caller_result_close;
	469	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	470	prsst = WAMP_PARSE_STATE_ID_PUSH;
	471	break;
	472	/* [REGISTER, Request\|id, Options\|dict, Procedure\|uri] */
	473	case WAMP_CODE_REGISTER:
	474	wamp_dealer_register(&s->dealer);
	475	s->proc_handler = wamp_proc_register_state;
	476	s->message_close_handler = wamp_dealer_register_close;
	477	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	478	prsst = WAMP_PARSE_STATE_ID_PUSH;
	479	break;
	480	/* [REGISTERED, REGISTER.Request\|id, Registration\|id] */
	481	case WAMP_CODE_REGISTERED:
	482	wamp_callee_registered(&s->callee);
	483	s->proc_handler = wamp_proc_registered_state;
	484	s->message_close_handler = wamp_callee_registered_close;
	485	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	486	prsst = WAMP_PARSE_STATE_ID_PUSH;
	487	break;
	488	/* [UNREGISTER, Request\|id, REGISTERED.Registration\|id] */
	489	case WAMP_CODE_UNREGISTER:
	490	wamp_dealer_unregister(&s->dealer);
	491	s->proc_handler = wamp_proc_unregister_state;
	492	s->message_close_handler = wamp_dealer_unregister_close;
	493	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	494	prsst = WAMP_PARSE_STATE_ID_PUSH;
	495	break;
	496	/* [UNREGISTERED, UNREGISTER.Request\|id] */
	497	case WAMP_CODE_UNREGISTERED:
	498	wamp_callee_unregistered(&s->callee);
	499	s->proc_handler = wamp_proc_unregistered_state;
	500	s->message_close_handler = wamp_callee_unregistered_close;
	501	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	502	prsst = WAMP_PARSE_STATE_ID_PUSH;
	503	break;
	504	/* [INVOCATION, Request\|id, REGISTERED.Registration\|id, Details\|dict, CALL.Arguments\|list, CALL.ArgumentsKw\|dict] */
	505	case WAMP_CODE_INVOCATION:
	506	wamp_callee_invocation(&s->callee);
	507	s->proc_handler = wamp_proc_invocation_state;
	508	s->message_close_handler = wamp_callee_invocation_close;
	509	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	510	prsst = WAMP_PARSE_STATE_ID_PUSH;
	511	break;
	512	/* [INTERRUPT, INVOCATION.Request\|id, Options\|dict] */
	513	case WAMP_CODE_INTERRUPT:
	514	wamp_callee_interrupt(&s->callee);
	515	s->proc_handler = wamp_proc_interrupt_state;
	516	s->message_close_handler = wamp_callee_interrupt_close;
	517	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	518	prsst = WAMP_PARSE_STATE_ID_PUSH;
	519	break;
	520	/* [YIELD, INVOCATION.Request\|id, Options\|dict, Arguments\|list, ArgumentsKw\|dict] */
	521	case WAMP_CODE_YIELD:
	522	wamp_dealer_yield(&s->dealer);
	523	s->proc_handler = wamp_proc_yield_state;
	524	s->message_close_handler = wamp_dealer_yield_close;
	525	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	526	prsst = WAMP_PARSE_STATE_ID_PUSH;
	527	break;
	528	default:
	529	s->proc_handler = NULL;
	530	break;
	531	}
	532
	533	/* mÁÄ¢ébZ[WR[h¾Á½ç */
	534	if (s->proc_handler != NULL) {
	535	/* p[^æ¾óÔÉÚé */
	536	s->code = (wamp_code_t)code;
	537	}
	538	}
	539
	540	/* bZ[WR[hªæ¾Å«È¯êÎG[ */
	541	s->state = prsst;
	542	}
	543
	544	static void wamp_id_parse_state(wamp_state_t *s, jsonsl_action_t action,
	545	struct jsonsl_state_st state, const char buf)
	546	{
	547	/* bZ[WR[hÌæ¾Jn */
	548	if ((action == JSONSL_ACTION_PUSH)
	549	&& (state->type == JSONSL_T_SPECIAL)) {
	550	s->param_handler(s, action, s->prmst, NULL);
	551	/* bZ[WR[hæ¾óÔÉÚé */
	552	s->state = WAMP_PARSE_STATE_PARAM;
	553	}
	554	else
	555	/* bZ[WR[hªæ¾Å«È¯êÎG[ */
	556	s->state = WAMP_PARSE_STATE_ERROR;
	557	}
	558
	559	static void wamp_list_parse_state(wamp_state_t *s, jsonsl_action_t action,
	560	struct jsonsl_state_st state, const char buf)
	561	{
	562	/* bZ[WR[hÌæ¾Jn */
	563	if ((action == JSONSL_ACTION_PUSH)
	564	&& (state->type == JSONSL_T_LIST)) {
	565	s->param_handler(s, action, s->prmst, NULL);
	566	/* bZ[WR[hæ¾óÔÉÚé */
	567	s->state = WAMP_PARSE_STATE_PARAM;
	568	}
	569	else
	570	/* bZ[WR[hªæ¾Å«È¯êÎG[ */
	571	s->state = WAMP_PARSE_STATE_ERROR;
	572	}
	573
	574	static void wamp_dict_parse_state(wamp_state_t *s, jsonsl_action_t action,
	575	struct jsonsl_state_st state, const char buf)
	576	{
	577	/* bZ[WR[hÌæ¾Jn */
	578	if ((action == JSONSL_ACTION_PUSH)
	579	&& (state->type == JSONSL_T_OBJECT)) {
	580	s->param_handler(s, action, s->prmst, NULL);
	581	/* bZ[WR[hæ¾óÔÉÚé */
	582	s->state = WAMP_PARSE_STATE_PARAM;
	583	}
	584	else
	585	/* bZ[WR[hªæ¾Å«È¯êÎG[ */
	586	s->state = WAMP_PARSE_STATE_ERROR;
	587	}
	588
	589	static void wamp_uri_parse_state(wamp_state_t *s, jsonsl_action_t action,
	590	struct jsonsl_state_st state, const char buf)
	591	{
	592	/* bZ[WR[hÌæ¾Jn */
	593	if ((action == JSONSL_ACTION_PUSH)
	594	&& (state->type == JSONSL_T_STRING)) {
	595	s->param_handler(s, action, s->prmst, NULL);
	596	/* bZ[WR[hæ¾óÔÉÚé */
	597	s->state = WAMP_PARSE_STATE_PARAM;
	598	}
	599	else
	600	/* bZ[WR[hªæ¾Å«È¯êÎG[ */
	601	s->state = WAMP_PARSE_STATE_ERROR;
	602	}
	603
	604	static void wamp_int_parse_state(wamp_state_t *s, jsonsl_action_t action,
	605	struct jsonsl_state_st state, const char buf)
	606	{
	607	/* bZ[WR[hÌæ¾Jn */
	608	if ((action == JSONSL_ACTION_PUSH)
	609	&& (state->type == JSONSL_T_SPECIAL)) {
	610	s->param_handler(s, action, s->prmst, NULL);
	611	/* bZ[WR[hæ¾óÔÉÚé */
	612	s->state = WAMP_PARSE_STATE_PARAM;
	613	}
	614	else
	615	/* bZ[WR[hªæ¾Å«È¯êÎG[ */
	616	s->state = WAMP_PARSE_STATE_ERROR;
	617	}
	618
	619	static void wamp_string_parse_state(wamp_state_t *s, jsonsl_action_t action,
	620	struct jsonsl_state_st state, const char buf)
	621	{
	622	/* bZ[WR[hÌæ¾Jn */
	623	if ((action == JSONSL_ACTION_PUSH)
	624	&& (state->type == JSONSL_T_STRING)) {
	625	s->param_handler(s, action, s->prmst, NULL);
	626	/* bZ[WR[hæ¾óÔÉÚé */
	627	s->state = WAMP_PARSE_STATE_PARAM;
	628	}
	629	else
	630	/* bZ[WR[hªæ¾Å«È¯êÎG[ */
	631	s->state = WAMP_PARSE_STATE_ERROR;
	632	}
	633
	634	static void wamp_param_parse_state(wamp_state_t *s, jsonsl_action_t action,
	635	struct jsonsl_state_st state, const char buf)
	636	{
	637	/* R[h²ÆÌðÀs */
	638	s->proc_handler(s, action, state, buf);
	639
	640	/* WAMPbZ[WÌö¾Á½ç */
	641	if ((state->level == 1) && (action == JSONSL_ACTION_POP)
	642	&& (state->type == JSONSL_T_LIST)) {
	643	s->prmst = WAMP_PARAM_STATE_NONE;
	644	s->message_close_handler(s);
	645	jsonsl_reset((jsonsl_t)s->jsn);
	646	/* Ò@óÔÉÚé */
	647	s->state = WAMP_PARSE_STATE_IDLE;
	648	}
	649	}
	650
	651	static void wamp_nomore_param_parse_state(wamp_state_t *s, jsonsl_action_t action,
	652	struct jsonsl_state_st state, const char buf)
	653	{
	654	/* WAMPbZ[WÌö¾Á½ç */
	655	if ((state->level == 1) && (action == JSONSL_ACTION_POP)
	656	&& (state->type == JSONSL_T_LIST)) {
	657	s->message_close_handler(s);
	658	jsonsl_reset((jsonsl_t)s->jsn);
	659	/* Ò@óÔÉÚé */
	660	s->state = WAMP_PARSE_STATE_IDLE;
	661	}
	662	else
	663	/* bZ[WR[hªæ¾Å«È¯êÎG[ */
	664	s->state = WAMP_PARSE_STATE_ERROR;
	665	}
	666
	667	/*
	668	* [HELLO, Realm\|uri, Details\|dict]
	669	*/
	670	static void wamp_proc_hello_state(wamp_state_t *s, jsonsl_action_t action,
	671	struct jsonsl_state_st state, const char buf)
	672	{
	673	switch (s->prmst) {
	674	case WAMP_PARAM_STATE_REALM_URI:
	675	if ((action == JSONSL_ACTION_POP)
	676	&& (state->type == JSONSL_T_STRING)) {
	677	wamp_router_hello_realm(&s->router, s->jsn_buf);
	678	s->prmst = WAMP_PARAM_STATE_DETAILS_DICT;
	679	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	680	}
	681	else
	682	s->state = WAMP_PARSE_STATE_ERROR;
	683	break;
	684	case WAMP_PARAM_STATE_DETAILS_DICT:
	685	if (state->level == 2) {
	686	if ((action == JSONSL_ACTION_POP)
	687	&& (state->type == JSONSL_T_OBJECT)) {
	688	wamp_router_hello_details(&s->router);
	689	s->prmst = WAMP_PARAM_STATE_NONE;
	690	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	691	}
	692	else
	693	s->state = WAMP_PARSE_STATE_ERROR;
	694	}
	695	else {
	696	wamp_router_hello_details_param(&s->router, action, state, buf);
	697	}
	698	break;
	699	default:
	700	s->state = WAMP_PARSE_STATE_ERROR;
	701	break;
	702	}
	703	}
	704
	705	/*
	706	* [WELCOME, Session\|id, Details\|dict]
	707	*/
	708	static void wamp_proc_welcome_state(wamp_state_t *s, jsonsl_action_t action,
	709	struct jsonsl_state_st state, const char buf)
	710	{
	711	switch (s->prmst) {
	712	case WAMP_PARAM_STATE_SESSION_ID:
	713	if ((action == JSONSL_ACTION_POP)
	714	&& (state->type == JSONSL_T_SPECIAL)) {
	715	wamp_client_welcome_client_id(&s->client, s->jsn_buf);
	716	s->prmst = WAMP_PARAM_STATE_DETAILS_DICT;
	717	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	718	}
	719	else
	720	s->state = WAMP_PARSE_STATE_ERROR;
	721	break;
	722	case WAMP_PARAM_STATE_DETAILS_DICT:
	723	if (state->level == 2) {
	724	if ((action == JSONSL_ACTION_POP)
	725	&& (state->type == JSONSL_T_OBJECT)) {
	726	wamp_client_welcome_details(&s->client, s->jsn_buf);
	727	s->prmst = WAMP_PARAM_STATE_NONE;
	728	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	729	}
	730	else
	731	s->state = WAMP_PARSE_STATE_ERROR;
	732	}
	733	else {
	734	wamp_client_welcome_details_param(&s->client, action, state, buf);
	735	}
	736	break;
	737	default:
	738	s->state = WAMP_PARSE_STATE_ERROR;
	739	break;
	740	}
	741	}
	742
	743	/*
	744	* [ABORT, Details\|dict, Reason\|uri]
	745	*/
	746	static void wamp_proc_abort_state(wamp_state_t *s, jsonsl_action_t action,
	747	struct jsonsl_state_st state, const char buf)
	748	{
	749	switch (s->prmst) {
	750	case WAMP_PARAM_STATE_DETAILS_DICT:
	751	if (state->level == 2) {
	752	if ((action == JSONSL_ACTION_POP)
	753	&& (state->type == JSONSL_T_OBJECT)) {
	754	wamp_client_abort_details(&s->client, s->jsn_buf);
	755	s->prmst = WAMP_PARAM_STATE_REASON_URI;
	756	s->state = WAMP_PARSE_STATE_URI_PUSH;
	757	}
	758	else
	759	s->state = WAMP_PARSE_STATE_ERROR;
	760	}
	761	else {
	762	wamp_client_abort_details_param(&s->client, action, state, buf);
	763	}
	764	break;
	765	case WAMP_PARAM_STATE_REASON_URI:
	766	if ((action == JSONSL_ACTION_POP)
	767	&& (state->type == JSONSL_T_STRING)) {
	768	wamp_client_abort_reason(&s->client, s->jsn_buf);
	769	s->prmst = WAMP_PARAM_STATE_NONE;
	770	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	771	}
	772	else
	773	s->state = WAMP_PARSE_STATE_ERROR;
	774	break;
	775	default:
	776	s->state = WAMP_PARSE_STATE_ERROR;
	777	break;
	778	}
	779	}
	780
	781	/*
	782	* [CHALLENGE, AuthMethod\|string, Extra\|dict]
	783	*/
	784	static void wamp_proc_challenge_state(wamp_state_t *s, jsonsl_action_t action,
	785	struct jsonsl_state_st state, const char buf)
	786	{
	787	switch (s->prmst) {
	788	case WAMP_PARAM_STATE_AUTHMETHOD_STRING:
	789	if ((action == JSONSL_ACTION_POP)
	790	&& (state->type == JSONSL_T_STRING)) {
	791	wamp_client_challenge_authmethod(&s->client, s->jsn_buf);
	792	s->prmst = WAMP_PARAM_STATE_EXTRA_DICT;
	793	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	794	}
	795	else
	796	s->state = WAMP_PARSE_STATE_ERROR;
	797	break;
	798	case WAMP_PARAM_STATE_EXTRA_DICT:
	799	if (state->level == 2) {
	800	if ((action == JSONSL_ACTION_POP)
	801	&& (state->type == JSONSL_T_OBJECT)) {
	802	wamp_client_challenge_extra(&s->client, s->jsn_buf);
	803	s->prmst = WAMP_PARAM_STATE_NONE;
	804	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	805	}
	806	else
	807	s->state = WAMP_PARSE_STATE_ERROR;
	808	}
	809	else {
	810	wamp_client_challenge_extra_param(&s->client, action, state, buf);
	811	}
	812	break;
	813	default:
	814	s->state = WAMP_PARSE_STATE_ERROR;
	815	break;
	816	}
	817	}
	818
	819	/*
	820	* [AUTHENTICATE, Signature\|string, Extra\|dict]
	821	*/
	822	static void wamp_proc_authenticate_state(wamp_state_t *s, jsonsl_action_t action,
	823	struct jsonsl_state_st state, const char buf)
	824	{
	825	switch (s->prmst) {
	826	case WAMP_PARAM_STATE_SIGNATURE_STRING:
	827	if ((action == JSONSL_ACTION_POP)
	828	&& (state->type == JSONSL_T_STRING)) {
	829	wamp_router_authenticate_signature(&s->router, s->jsn_buf);
	830	s->prmst = WAMP_PARAM_STATE_EXTRA_DICT;
	831	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	832	}
	833	else
	834	s->state = WAMP_PARSE_STATE_ERROR;
	835	break;
	836	case WAMP_PARAM_STATE_EXTRA_DICT:
	837	if (state->level == 2) {
	838	if ((action == JSONSL_ACTION_POP)
	839	&& (state->type == JSONSL_T_OBJECT)) {
	840	wamp_router_authenticate_extra(&s->router, s->jsn_buf);
	841	s->prmst = WAMP_PARAM_STATE_NONE;
	842	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	843	}
	844	else
	845	s->state = WAMP_PARSE_STATE_ERROR;
	846	}
	847	else {
	848	wamp_router_authenticate_extra_param(&s->router, action, state, buf);
	849	}
	850	break;
	851	default:
	852	s->state = WAMP_PARSE_STATE_ERROR;
	853	break;
	854	}
	855	}
	856
	857	/*
	858	* [GOODBYE, Details\|dict, Reason\|uri]
	859	*/
	860	static void wamp_proc_goodbye_state(wamp_state_t *s, jsonsl_action_t action,
	861	struct jsonsl_state_st state, const char buf)
	862	{
	863	switch (s->prmst) {
	864	case WAMP_PARAM_STATE_DETAILS_DICT:
	865	if (state->level == 2) {
	866	if ((action == JSONSL_ACTION_POP)
	867	&& (state->type == JSONSL_T_OBJECT)) {
	868	wamp_router_goodbye_details(&s->router);
	869	s->prmst = WAMP_PARAM_STATE_REASON_URI;
	870	s->state = WAMP_PARSE_STATE_URI_PUSH;
	871	}
	872	else
	873	s->state = WAMP_PARSE_STATE_ERROR;
	874	}
	875	else {
	876	wamp_router_goodbye_details_param(&s->router, action, state, buf);
	877	}
	878	break;
	879	case WAMP_PARAM_STATE_REASON_URI:
	880	if ((action == JSONSL_ACTION_POP)
	881	&& (state->type == JSONSL_T_STRING)) {
	882	wamp_router_goodbye_reason(&s->router, s->jsn_buf);
	883	s->prmst = WAMP_PARAM_STATE_NONE;
	884	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	885	}
	886	else
	887	s->state = WAMP_PARSE_STATE_ERROR;
	888	break;
	889	default:
	890	s->state = WAMP_PARSE_STATE_ERROR;
	891	break;
	892	}
	893	}
	894
	895	/*
	896	* [ERROR, REQUEST.Type\|int, REQUEST.Request\|id, Details\|dict, Error\|uri, Arguments\|list, ArgumentsKw\|dict]
	897	*/
	898	static void wamp_proc_error_state(wamp_state_t *s, jsonsl_action_t action,
	899	struct jsonsl_state_st state, const char buf)
	900	{
	901	switch (s->prmst) {
	902	case WAMP_PARAM_STATE_TYPE_INT:
	903	if ((action == JSONSL_ACTION_POP)
	904	&& (state->type == JSONSL_T_SPECIAL)) {
	905	wamp_error_type(s, s->jsn_buf);
	906	s->prmst = WAMP_PARAM_STATE_REQUEST_ID;
	907	s->state = WAMP_PARSE_STATE_ID_PUSH;
	908	}
	909	else
	910	s->state = WAMP_PARSE_STATE_ERROR;
	911	break;
	912	case WAMP_PARAM_STATE_REQUEST_ID:
	913	if ((action == JSONSL_ACTION_POP)
	914	&& (state->type == JSONSL_T_SPECIAL)) {
	915	wamp_error_request_id(s, s->jsn_buf);
	916	s->prmst = WAMP_PARAM_STATE_DETAILS_DICT;
	917	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	918	}
	919	else
	920	s->state = WAMP_PARSE_STATE_ERROR;
	921	break;
	922	case WAMP_PARAM_STATE_DETAILS_DICT:
	923	if (state->level == 2) {
	924	if ((action == JSONSL_ACTION_POP)
	925	&& (state->type == JSONSL_T_OBJECT)) {
	926	wamp_error_details(s, s->jsn_buf);
	927	s->prmst = WAMP_PARAM_STATE_ERROR_URI;
	928	s->state = WAMP_PARSE_STATE_URI_PUSH;
	929	}
	930	else
	931	s->state = WAMP_PARSE_STATE_ERROR;
	932	}
	933	else {
	934	wamp_error_details_param(s, action, state, buf);
	935	}
	936	break;
	937	case WAMP_PARAM_STATE_ERROR_URI:
	938	if ((action == JSONSL_ACTION_POP)
	939	&& (state->type == JSONSL_T_STRING)) {
	940	wamp_error_uri(s, s->jsn_buf);
	941	s->prmst = WAMP_PARAM_STATE_ARGUMENTS_LIST;
	942	s->state = WAMP_PARSE_STATE_LIST_PUSH;
	943	}
	944	else
	945	s->state = WAMP_PARSE_STATE_ERROR;
	946	break;
	947	case WAMP_PARAM_STATE_ARGUMENTS_LIST:
	948	if (state->level == 2) {
	949	if ((action == JSONSL_ACTION_POP)
	950	&& (state->type == JSONSL_T_LIST)) {
	951	wamp_error_arguments(s, s->jsn_buf);
	952	s->prmst = WAMP_PARAM_STATE_ARGUMENTSKW_DICT;
	953	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	954	}
	955	else
	956	s->state = WAMP_PARSE_STATE_ERROR;
	957	}
	958	else {
	959	wamp_error_arguments_param(s, action, state, buf);
	960	}
	961	break;
	962	case WAMP_PARAM_STATE_ARGUMENTSKW_DICT:
	963	if (state->level == 2) {
	964	if ((action == JSONSL_ACTION_POP)
	965	&& (state->type == JSONSL_T_OBJECT)) {
	966	wamp_error_argumentskw(s, s->jsn_buf);
	967	s->prmst = WAMP_PARAM_STATE_NONE;
	968	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	969	}
	970	else
	971	s->state = WAMP_PARSE_STATE_ERROR;
	972	}
	973	else {
	974	wamp_error_argumentskw_param(s, action, state, buf);
	975	}
	976	break;
	977	default:
	978	s->state = WAMP_PARSE_STATE_ERROR;
	979	break;
	980	}
	981	}
	982
	983	/*
	984	* [PUBLISH, Request\|id, Options\|dict, Topic\|uri, Arguments\|list, ArgumentsKw\|dict]
	985	*/
	986	static void wamp_proc_publish_state(wamp_state_t *s, jsonsl_action_t action,
	987	struct jsonsl_state_st state, const char buf)
	988	{
	989	switch (s->prmst) {
	990	case WAMP_PARAM_STATE_REQUEST_ID:
	991	if ((action == JSONSL_ACTION_POP)
	992	&& (state->type == JSONSL_T_SPECIAL)) {
	993	wamp_broker_publish_request_id(&s->broker, s->jsn_buf);
	994	s->prmst = WAMP_PARAM_STATE_OPTIONS_DICT;
	995	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	996	}
	997	else
	998	s->state = WAMP_PARSE_STATE_ERROR;
	999	break;
	1000	case WAMP_PARAM_STATE_OPTIONS_DICT:
	1001	if (state->level == 2) {
	1002	if ((action == JSONSL_ACTION_POP)
	1003	&& (state->type == JSONSL_T_OBJECT)) {
	1004	wamp_broker_publish_options(&s->broker, s->jsn_buf);
	1005	s->prmst = WAMP_PARAM_STATE_TOPIC_URI;
	1006	s->state = WAMP_PARSE_STATE_URI_PUSH;
	1007	}
	1008	else
	1009	s->state = WAMP_PARSE_STATE_ERROR;
	1010	}
	1011	else {
	1012	wamp_broker_publish_options_param(&s->broker, action, state, buf);
	1013	}
	1014	break;
	1015	case WAMP_PARAM_STATE_TOPIC_URI:
	1016	if ((action == JSONSL_ACTION_POP)
	1017	&& (state->type == JSONSL_T_STRING)) {
	1018	wamp_broker_publish_topic(&s->broker, s->jsn_buf);
	1019	s->prmst = WAMP_PARAM_STATE_ARGUMENTS_LIST;
	1020	s->state = WAMP_PARSE_STATE_LIST_PUSH;
	1021	}
	1022	else
	1023	s->state = WAMP_PARSE_STATE_ERROR;
	1024	break;
	1025	case WAMP_PARAM_STATE_ARGUMENTS_LIST:
	1026	if (state->level == 2) {
	1027	if ((action == JSONSL_ACTION_POP)
	1028	&& (state->type == JSONSL_T_LIST)) {
	1029	wamp_broker_publish_arguments(&s->broker, s->jsn_buf);
	1030	s->prmst = WAMP_PARAM_STATE_ARGUMENTSKW_DICT;
	1031	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1032	}
	1033	else
	1034	s->state = WAMP_PARSE_STATE_ERROR;
	1035	}
	1036	else {
	1037	wamp_broker_publish_arguments_param(&s->broker, action, state, buf);
	1038	}
	1039	break;
	1040	case WAMP_PARAM_STATE_ARGUMENTSKW_DICT:
	1041	if (state->level == 2) {
	1042	if ((action == JSONSL_ACTION_POP)
	1043	&& (state->type == JSONSL_T_OBJECT)) {
	1044	wamp_broker_publish_argumentskw(&s->broker, s->jsn_buf);
	1045	s->prmst = WAMP_PARAM_STATE_NONE;
	1046	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1047	}
	1048	else
	1049	s->state = WAMP_PARSE_STATE_ERROR;
	1050	}
	1051	else {
	1052	wamp_broker_publish_argumentskw_param(&s->broker, action, state, buf);
	1053	}
	1054	break;
	1055	default:
	1056	s->state = WAMP_PARSE_STATE_ERROR;
	1057	break;
	1058	}
	1059	}
	1060
	1061	/*
	1062	* [PUBLISHED, PUBLISH.Request\|id, Publication\|id]
	1063	*/
	1064	static void wamp_proc_published_state(wamp_state_t *s, jsonsl_action_t action,
	1065	struct jsonsl_state_st state, const char buf)
	1066	{
	1067	switch (s->prmst) {
	1068	case WAMP_PARAM_STATE_REQUEST_ID:
	1069	if ((action == JSONSL_ACTION_POP)
	1070	&& (state->type == JSONSL_T_SPECIAL)) {
	1071	wamp_publisher_published_request_id(&s->publisher, s->jsn_buf);
	1072	s->prmst = WAMP_PARAM_STATE_PUBLICATION_ID;
	1073	s->state = WAMP_PARSE_STATE_ID_PUSH;
	1074	}
	1075	else
	1076	s->state = WAMP_PARSE_STATE_ERROR;
	1077	break;
	1078	case WAMP_PARAM_STATE_PUBLICATION_ID:
	1079	if ((action == JSONSL_ACTION_POP)
	1080	&& (state->type == JSONSL_T_SPECIAL)) {
	1081	wamp_publisher_published_publication_id(&s->publisher, s->jsn_buf);
	1082	s->prmst = WAMP_PARAM_STATE_NONE;
	1083	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1084	}
	1085	else
	1086	s->state = WAMP_PARSE_STATE_ERROR;
	1087	break;
	1088	default:
	1089	s->state = WAMP_PARSE_STATE_ERROR;
	1090	break;
	1091	}
	1092	}
	1093
	1094	/*
	1095	* [SUBSCRIBE, Request\|id, Options\|dict, Topic\|uri]
	1096	*/
	1097	static void wamp_proc_subscribe_state(wamp_state_t *s, jsonsl_action_t action,
	1098	struct jsonsl_state_st state, const char buf)
	1099	{
	1100	switch (s->prmst) {
	1101	case WAMP_PARAM_STATE_REQUEST_ID:
	1102	if ((action == JSONSL_ACTION_POP)
	1103	&& (state->type == JSONSL_T_SPECIAL)) {
	1104	wamp_broker_subscribe_request_id(&s->broker, s->jsn_buf);
	1105	s->prmst = WAMP_PARAM_STATE_OPTIONS_DICT;
	1106	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1107	}
	1108	else
	1109	s->state = WAMP_PARSE_STATE_ERROR;
	1110	break;
	1111	case WAMP_PARAM_STATE_OPTIONS_DICT:
	1112	if (state->level == 2) {
	1113	if ((action == JSONSL_ACTION_POP)
	1114	&& (state->type == JSONSL_T_OBJECT)) {
	1115	wamp_broker_subscribe_options(&s->broker);
	1116	s->prmst = WAMP_PARAM_STATE_TOPIC_URI;
	1117	s->state = WAMP_PARSE_STATE_URI_PUSH;
	1118	}
	1119	else
	1120	s->state = WAMP_PARSE_STATE_ERROR;
	1121	}
	1122	else {
	1123	wamp_broker_subscribe_options_param(&s->broker, action, state, buf);
	1124	}
	1125	break;
	1126	case WAMP_PARAM_STATE_TOPIC_URI:
	1127	if ((action == JSONSL_ACTION_POP)
	1128	&& (state->type == JSONSL_T_STRING)) {
	1129	wamp_broker_subscribe_topic(&s->broker, s->jsn_buf);
	1130	s->prmst = WAMP_PARAM_STATE_NONE;
	1131	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1132	}
	1133	else
	1134	s->state = WAMP_PARSE_STATE_ERROR;
	1135	break;
	1136	default:
	1137	s->state = WAMP_PARSE_STATE_ERROR;
	1138	break;
	1139	}
	1140	}
	1141
	1142	/*
	1143	* [SUBSCRIBED, SUBSCRIBE.Request\|id, Subscription\|id]
	1144	*/
	1145	static void wamp_proc_subscribed_state(wamp_state_t *s, jsonsl_action_t action,
	1146	struct jsonsl_state_st state, const char buf)
	1147	{
	1148	switch (s->prmst) {
	1149	case WAMP_PARAM_STATE_REQUEST_ID:
	1150	if ((action == JSONSL_ACTION_POP)
	1151	&& (state->type == JSONSL_T_SPECIAL)) {
	1152	wamp_subscriber_subscribed_request_id(&s->subscriber, s->jsn_buf);
	1153	s->prmst = WAMP_PARAM_STATE_SUBSCRIPTION_ID;
	1154	s->state = WAMP_PARSE_STATE_ID_PUSH;
	1155	}
	1156	else
	1157	s->state = WAMP_PARSE_STATE_ERROR;
	1158	break;
	1159	case WAMP_PARAM_STATE_SUBSCRIPTION_ID:
	1160	if ((action == JSONSL_ACTION_POP)
	1161	&& (state->type == JSONSL_T_SPECIAL)) {
	1162	wamp_subscriber_subscribed_subscription_id(&s->subscriber, s->jsn_buf);
	1163	s->prmst = WAMP_PARAM_STATE_NONE;
	1164	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1165	}
	1166	else
	1167	s->state = WAMP_PARSE_STATE_ERROR;
	1168	break;
	1169	default:
	1170	s->state = WAMP_PARSE_STATE_ERROR;
	1171	break;
	1172	}
	1173	}
	1174
	1175	/*
	1176	* [UNSUBSCRIBE, Request\|id, SUBSCRIBED.Subscription\|id]
	1177	*/
	1178	static void wamp_proc_unsubscribe_state(wamp_state_t *s, jsonsl_action_t action,
	1179	struct jsonsl_state_st state, const char buf)
	1180	{
	1181	switch (s->prmst) {
	1182	case WAMP_PARAM_STATE_REQUEST_ID:
	1183	if ((action == JSONSL_ACTION_POP)
	1184	&& (state->type == JSONSL_T_SPECIAL)) {
	1185	wamp_broker_unsubscribe_request_id(&s->broker, s->jsn_buf);
	1186	s->prmst = WAMP_PARAM_STATE_SUBSCRIPTION_ID;
	1187	s->state = WAMP_PARSE_STATE_ID_PUSH;
	1188	}
	1189	else
	1190	s->state = WAMP_PARSE_STATE_ERROR;
	1191	break;
	1192	case WAMP_PARAM_STATE_SUBSCRIPTION_ID:
	1193	if ((action == JSONSL_ACTION_POP)
	1194	&& (state->type == JSONSL_T_SPECIAL)) {
	1195	wamp_broker_unsubscribe_subscription_id(&s->broker, s->jsn_buf);
	1196	s->prmst = WAMP_PARAM_STATE_NONE;
	1197	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1198	}
	1199	else
	1200	s->state = WAMP_PARSE_STATE_ERROR;
	1201	break;
	1202	default:
	1203	s->state = WAMP_PARSE_STATE_ERROR;
	1204	break;
	1205	}
	1206	}
	1207
	1208	/*
	1209	* [UNSUBSCRIBED, UNSUBSCRIBE.Request\|id]
	1210	*/
	1211	static void wamp_proc_unsubscribed_state(wamp_state_t *s, jsonsl_action_t action,
	1212	struct jsonsl_state_st state, const char buf)
	1213	{
	1214	switch (s->prmst) {
	1215	case WAMP_PARAM_STATE_REQUEST_ID:
	1216	if ((action == JSONSL_ACTION_POP)
	1217	&& (state->type == JSONSL_T_SPECIAL)) {
	1218	wamp_subscriber_unsubscribed_request_id(&s->subscriber, s->jsn_buf);
	1219	s->prmst = WAMP_PARAM_STATE_NONE;
	1220	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1221	}
	1222	else
	1223	s->state = WAMP_PARSE_STATE_ERROR;
	1224	break;
	1225	default:
	1226	s->state = WAMP_PARSE_STATE_ERROR;
	1227	break;
	1228	}
	1229	}
	1230
	1231	/*
	1232	* [EVENT, SUBSCRIBED.Subscription\|id, PUBLISHED.Publication\|id, Details\|dict, PUBLISH.Arguments\|list, PUBLISH.ArgumentsKw\|dict]
	1233	*/
	1234	static void wamp_proc_event_state(wamp_state_t *s, jsonsl_action_t action,
	1235	struct jsonsl_state_st state, const char buf)
	1236	{
	1237	switch (s->prmst) {
	1238	case WAMP_PARAM_STATE_SUBSCRIPTION_ID:
	1239	if ((action == JSONSL_ACTION_POP)
	1240	&& (state->type == JSONSL_T_SPECIAL)) {
	1241	wamp_subscriber_event_subscription_id(&s->subscriber, s->jsn_buf);
	1242	s->prmst = WAMP_PARAM_STATE_PUBLICATION_ID;
	1243	s->state = WAMP_PARSE_STATE_ID_PUSH;
	1244	}
	1245	else
	1246	s->state = WAMP_PARSE_STATE_ERROR;
	1247	break;
	1248	case WAMP_PARAM_STATE_PUBLICATION_ID:
	1249	if ((action == JSONSL_ACTION_POP)
	1250	&& (state->type == JSONSL_T_SPECIAL)) {
	1251	wamp_subscriber_event_publication_id(&s->subscriber, s->jsn_buf);
	1252	s->prmst = WAMP_PARAM_STATE_DETAILS_DICT;
	1253	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1254	}
	1255	else
	1256	s->state = WAMP_PARSE_STATE_ERROR;
	1257	break;
	1258	case WAMP_PARAM_STATE_DETAILS_DICT:
	1259	if (state->level == 2) {
	1260	if ((action == JSONSL_ACTION_POP)
	1261	&& (state->type == JSONSL_T_OBJECT)) {
	1262	wamp_subscriber_event_details(&s->subscriber, s->jsn_buf);
	1263	s->prmst = WAMP_PARAM_STATE_ARGUMENTS_LIST;
	1264	s->state = WAMP_PARSE_STATE_LIST_PUSH;
	1265	}
	1266	else
	1267	s->state = WAMP_PARSE_STATE_ERROR;
	1268	}
	1269	else {
	1270	wamp_subscriber_event_details_param(&s->subscriber, action, state, buf);
	1271	}
	1272	break;
	1273	case WAMP_PARAM_STATE_ARGUMENTS_LIST:
	1274	if (state->level == 2) {
	1275	if ((action == JSONSL_ACTION_POP)
	1276	&& (state->type == JSONSL_T_LIST)) {
	1277	wamp_subscriber_event_arguments(&s->subscriber, s->jsn_buf);
	1278	s->prmst = WAMP_PARAM_STATE_ARGUMENTSKW_DICT;
	1279	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1280	}
	1281	else
	1282	s->state = WAMP_PARSE_STATE_ERROR;
	1283	}
	1284	else {
	1285	wamp_subscriber_event_arguments_param(&s->subscriber, action, state, buf);
	1286	}
	1287	break;
	1288	case WAMP_PARAM_STATE_ARGUMENTSKW_DICT:
	1289	if (state->level == 2) {
	1290	if ((action == JSONSL_ACTION_POP)
	1291	&& (state->type == JSONSL_T_OBJECT)) {
	1292	wamp_subscriber_event_argumentskw(&s->subscriber, s->jsn_buf);
	1293	s->prmst = WAMP_PARAM_STATE_NONE;
	1294	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1295	}
	1296	else
	1297	s->state = WAMP_PARSE_STATE_ERROR;
	1298	}
	1299	else {
	1300	wamp_subscriber_event_argumentskw_param(&s->subscriber, action, state, buf);
	1301	}
	1302	break;
	1303	default:
	1304	s->state = WAMP_PARSE_STATE_ERROR;
	1305	break;
	1306	}
	1307	}
	1308
	1309	/*
	1310	* [CALL, Request\|id, Options\|dict, Procedure\|uri, Arguments\|list, ArgumentsKw\|dict]
	1311	*/
	1312	static void wamp_proc_call_state(wamp_state_t *s, jsonsl_action_t action,
	1313	struct jsonsl_state_st state, const char buf)
	1314	{
	1315	switch (s->prmst) {
	1316	case WAMP_PARAM_STATE_REQUEST_ID:
	1317	if ((action == JSONSL_ACTION_POP)
	1318	&& (state->type == JSONSL_T_SPECIAL)) {
	1319	wamp_dealer_call_request_id(&s->dealer, s->jsn_buf);
	1320	s->prmst = WAMP_PARAM_STATE_OPTIONS_DICT;
	1321	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1322	}
	1323	else
	1324	s->state = WAMP_PARSE_STATE_ERROR;
	1325	break;
	1326	case WAMP_PARAM_STATE_OPTIONS_DICT:
	1327	if (state->level == 2) {
	1328	if ((action == JSONSL_ACTION_POP)
	1329	&& (state->type == JSONSL_T_OBJECT)) {
	1330	wamp_dealer_call_options(&s->dealer, s->jsn_buf);
	1331	s->prmst = WAMP_PARAM_STATE_PROCEDURE_URI;
	1332	s->state = WAMP_PARSE_STATE_URI_PUSH;
	1333	}
	1334	else
	1335	s->state = WAMP_PARSE_STATE_ERROR;
	1336	}
	1337	else {
	1338	wamp_dealer_call_options_param(&s->dealer, action, state, buf);
	1339	}
	1340	break;
	1341	case WAMP_PARAM_STATE_PROCEDURE_URI:
	1342	if ((action == JSONSL_ACTION_POP)
	1343	&& (state->type == JSONSL_T_STRING)) {
	1344	wamp_dealer_call_procedure(&s->dealer, s->jsn_buf);
	1345	s->prmst = WAMP_PARAM_STATE_ARGUMENTS_LIST;
	1346	s->state = WAMP_PARSE_STATE_LIST_PUSH;
	1347	}
	1348	else
	1349	s->state = WAMP_PARSE_STATE_ERROR;
	1350	break;
	1351	case WAMP_PARAM_STATE_ARGUMENTS_LIST:
	1352	if (state->level == 2) {
	1353	if ((action == JSONSL_ACTION_POP)
	1354	&& (state->type == JSONSL_T_LIST)) {
	1355	wamp_dealer_call_arguments(&s->dealer, s->jsn_buf);
	1356	s->prmst = WAMP_PARAM_STATE_ARGUMENTSKW_DICT;
	1357	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1358	}
	1359	else
	1360	s->state = WAMP_PARSE_STATE_ERROR;
	1361	}
	1362	else {
	1363	wamp_dealer_call_argumentskw_param(&s->dealer, action, state, buf);
	1364	}
	1365	break;
	1366	case WAMP_PARAM_STATE_ARGUMENTSKW_DICT:
	1367	if (state->level == 2) {
	1368	if ((action == JSONSL_ACTION_POP)
	1369	&& (state->type == JSONSL_T_OBJECT)) {
	1370	wamp_dealer_call_argumentskw(&s->dealer, s->jsn_buf);
	1371	s->prmst = WAMP_PARAM_STATE_NONE;
	1372	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1373	}
	1374	else
	1375	s->state = WAMP_PARSE_STATE_ERROR;
	1376	}
	1377	else {
	1378	wamp_dealer_call_argumentskw_param(&s->dealer, action, state, buf);
	1379	}
	1380	break;
	1381	default:
	1382	s->state = WAMP_PARSE_STATE_ERROR;
	1383	break;
	1384	}
	1385	}
	1386
	1387	/*
	1388	* [CANCEL, CALL.Request\|id, Options\|dict]
	1389	*/
	1390	static void wamp_proc_cancel_state(wamp_state_t *s, jsonsl_action_t action,
	1391	struct jsonsl_state_st state, const char buf)
	1392	{
	1393	switch (s->prmst) {
	1394	case WAMP_PARAM_STATE_REQUEST_ID:
	1395	if ((action == JSONSL_ACTION_POP)
	1396	&& (state->type == JSONSL_T_SPECIAL)) {
	1397	wamp_dealer_cansel_request_id(&s->dealer, s->jsn_buf);
	1398	s->prmst = WAMP_PARAM_STATE_OPTIONS_DICT;
	1399	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1400	}
	1401	else
	1402	s->state = WAMP_PARSE_STATE_ERROR;
	1403	break;
	1404	case WAMP_PARAM_STATE_OPTIONS_DICT:
	1405	if (state->level == 2) {
	1406	if ((action == JSONSL_ACTION_POP)
	1407	&& (state->type == JSONSL_T_OBJECT)) {
	1408	wamp_dealer_cansel_options(&s->dealer, s->jsn_buf);
	1409	s->prmst = WAMP_PARAM_STATE_NONE;
	1410	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1411	}
	1412	else
	1413	s->state = WAMP_PARSE_STATE_ERROR;
	1414	}
	1415	else {
	1416	wamp_dealer_cansel_options_param(&s->dealer, action, state, buf);
	1417	}
	1418	break;
	1419	default:
	1420	s->state = WAMP_PARSE_STATE_ERROR;
	1421	break;
	1422	}
	1423	}
	1424
	1425	/*
	1426	* [RESULT, CALL.Request\|id, Details\|dict, YIELD.Arguments\|list, YIELD.ArgumentsKw\|dict]
	1427	*/
	1428	static void wamp_proc_result_state(wamp_state_t *s, jsonsl_action_t action,
	1429	struct jsonsl_state_st state, const char buf)
	1430	{
	1431	switch (s->prmst) {
	1432	case WAMP_PARAM_STATE_REQUEST_ID:
	1433	if ((action == JSONSL_ACTION_POP)
	1434	&& (state->type == JSONSL_T_SPECIAL)) {
	1435	wamp_caller_result_request_id(&s->caller, s->jsn_buf);
	1436	s->prmst = WAMP_PARAM_STATE_DETAILS_DICT;
	1437	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1438	}
	1439	else
	1440	s->state = WAMP_PARSE_STATE_ERROR;
	1441	break;
	1442	case WAMP_PARAM_STATE_DETAILS_DICT:
	1443	if (state->level == 2) {
	1444	if ((action == JSONSL_ACTION_POP)
	1445	&& (state->type == JSONSL_T_OBJECT)) {
	1446	wamp_caller_result_details(&s->caller, s->jsn_buf);
	1447	s->prmst = WAMP_PARAM_STATE_ARGUMENTS_LIST;
	1448	s->state = WAMP_PARSE_STATE_LIST_PUSH;
	1449	}
	1450	else
	1451	s->state = WAMP_PARSE_STATE_ERROR;
	1452	}
	1453	else {
	1454	wamp_caller_result_details_param(&s->caller, action, state, buf);
	1455	}
	1456	break;
	1457	case WAMP_PARAM_STATE_ARGUMENTS_LIST:
	1458	if (state->level == 2) {
	1459	if ((action == JSONSL_ACTION_POP)
	1460	&& (state->type == JSONSL_T_LIST)) {
	1461	wamp_caller_result_arguments(&s->caller, s->jsn_buf);
	1462	s->prmst = WAMP_PARAM_STATE_ARGUMENTSKW_DICT;
	1463	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1464	}
	1465	else
	1466	s->state = WAMP_PARSE_STATE_ERROR;
	1467	}
	1468	else {
	1469	wamp_caller_result_arguments_param(&s->caller, action, state, buf);
	1470	}
	1471	break;
	1472	case WAMP_PARAM_STATE_ARGUMENTSKW_DICT:
	1473	if (state->level == 2) {
	1474	if ((action == JSONSL_ACTION_POP)
	1475	&& (state->type == JSONSL_T_OBJECT)) {
	1476	wamp_caller_result_argumentskw(&s->caller, s->jsn_buf);
	1477	s->prmst = WAMP_PARAM_STATE_NONE;
	1478	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1479	}
	1480	else
	1481	s->state = WAMP_PARSE_STATE_ERROR;
	1482	}
	1483	else {
	1484	wamp_caller_result_argumentskw_param(&s->caller, action, state, buf);
	1485	}
	1486	break;
	1487	default:
	1488	s->state = WAMP_PARSE_STATE_ERROR;
	1489	break;
	1490	}
	1491	}
	1492
	1493	/*
	1494	* [REGISTER, Request\|id, Options\|dict, Procedure\|uri]
	1495	*/
	1496	static void wamp_proc_register_state(wamp_state_t *s, jsonsl_action_t action,
	1497	struct jsonsl_state_st state, const char buf)
	1498	{
	1499	switch (s->prmst) {
	1500	case WAMP_PARAM_STATE_REQUEST_ID:
	1501	if ((action == JSONSL_ACTION_POP)
	1502	&& (state->type == JSONSL_T_SPECIAL)) {
	1503	wamp_dealer_register_request_id(&s->dealer, s->jsn_buf);
	1504	s->prmst = WAMP_PARAM_STATE_OPTIONS_DICT;
	1505	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1506	}
	1507	else
	1508	s->state = WAMP_PARSE_STATE_ERROR;
	1509	break;
	1510	case WAMP_PARAM_STATE_OPTIONS_DICT:
	1511	if (state->level == 2) {
	1512	if ((action == JSONSL_ACTION_POP)
	1513	&& (state->type == JSONSL_T_OBJECT)) {
	1514	wamp_dealer_register_options(&s->dealer, s->jsn_buf);
	1515	s->prmst = WAMP_PARAM_STATE_PROCEDURE_URI;
	1516	s->state = WAMP_PARSE_STATE_URI_PUSH;
	1517	}
	1518	else
	1519	s->state = WAMP_PARSE_STATE_ERROR;
	1520	}
	1521	else {
	1522	wamp_dealer_register_options_param(&s->dealer, action, state, buf);
	1523	}
	1524	break;
	1525	case WAMP_PARAM_STATE_PROCEDURE_URI:
	1526	if ((action == JSONSL_ACTION_POP)
	1527	&& (state->type == JSONSL_T_STRING)) {
	1528	wamp_dealer_register_procedure(&s->dealer, s->jsn_buf);
	1529	s->prmst = WAMP_PARAM_STATE_NONE;
	1530	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1531	}
	1532	else
	1533	s->state = WAMP_PARSE_STATE_ERROR;
	1534	break;
	1535	default:
	1536	s->state = WAMP_PARSE_STATE_ERROR;
	1537	break;
	1538	}
	1539	}
	1540
	1541	/*
	1542	* [REGISTERED, REGISTER.Request\|id, Registration\|id]
	1543	*/
	1544	static void wamp_proc_registered_state(wamp_state_t *s, jsonsl_action_t action,
	1545	struct jsonsl_state_st state, const char buf)
	1546	{
	1547	switch (s->prmst) {
	1548	case WAMP_PARAM_STATE_REQUEST_ID:
	1549	if ((action == JSONSL_ACTION_POP)
	1550	&& (state->type == JSONSL_T_SPECIAL)) {
	1551	wamp_callee_registered_request_id(&s->callee, s->jsn_buf);
	1552	s->prmst = WAMP_PARAM_STATE_REGISTRATION_ID;
	1553	s->state = WAMP_PARSE_STATE_ID_PUSH;
	1554	}
	1555	else
	1556	s->state = WAMP_PARSE_STATE_ERROR;
	1557	break;
	1558	case WAMP_PARAM_STATE_REGISTRATION_ID:
	1559	if ((action == JSONSL_ACTION_POP)
	1560	&& (state->type == JSONSL_T_SPECIAL)) {
	1561	wamp_callee_registered_registration_id(&s->callee, s->jsn_buf);
	1562	s->prmst = WAMP_PARAM_STATE_NONE;
	1563	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1564	}
	1565	else
	1566	s->state = WAMP_PARSE_STATE_ERROR;
	1567	break;
	1568	default:
	1569	s->state = WAMP_PARSE_STATE_ERROR;
	1570	break;
	1571	}
	1572	}
	1573
	1574	/*
	1575	* [UNREGISTER, Request\|id, REGISTERED.Registration\|id]
	1576	*/
	1577	static void wamp_proc_unregister_state(wamp_state_t *s, jsonsl_action_t action,
	1578	struct jsonsl_state_st state, const char buf)
	1579	{
	1580	switch (s->prmst) {
	1581	case WAMP_PARAM_STATE_REQUEST_ID:
	1582	if ((action == JSONSL_ACTION_POP)
	1583	&& (state->type == JSONSL_T_SPECIAL)) {
	1584	wamp_dealer_unregister_request_id(&s->dealer, s->jsn_buf);
	1585	s->prmst = WAMP_PARAM_STATE_REGISTRATION_ID;
	1586	s->state = WAMP_PARSE_STATE_ID_PUSH;
	1587	}
	1588	else
	1589	s->state = WAMP_PARSE_STATE_ERROR;
	1590	break;
	1591	case WAMP_PARAM_STATE_REGISTRATION_ID:
	1592	if ((action == JSONSL_ACTION_POP)
	1593	&& (state->type == JSONSL_T_SPECIAL)) {
	1594	wamp_dealer_unregister_registration_id(&s->dealer, s->jsn_buf);
	1595	s->prmst = WAMP_PARAM_STATE_NONE;
	1596	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1597	}
	1598	else
	1599	s->state = WAMP_PARSE_STATE_ERROR;
	1600	break;
	1601	default:
	1602	s->state = WAMP_PARSE_STATE_ERROR;
	1603	break;
	1604	}
	1605	}
	1606
	1607	/*
	1608	* [UNREGISTERED, UNREGISTER.Request\|id]
	1609	*/
	1610	static void wamp_proc_unregistered_state(wamp_state_t *s, jsonsl_action_t action,
	1611	struct jsonsl_state_st state, const char buf)
	1612	{
	1613	switch (s->prmst) {
	1614	case WAMP_PARAM_STATE_REQUEST_ID:
	1615	if ((action == JSONSL_ACTION_POP)
	1616	&& (state->type == JSONSL_T_SPECIAL)) {
	1617	wamp_callee_unregistered_request_id(&s->callee, s->jsn_buf);
	1618	s->prmst = WAMP_PARAM_STATE_NONE;
	1619	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1620	}
	1621	else
	1622	s->state = WAMP_PARSE_STATE_ERROR;
	1623	break;
	1624	default:
	1625	s->state = WAMP_PARSE_STATE_ERROR;
	1626	break;
	1627	}
	1628	}
	1629
	1630	/*
	1631	* [INVOCATION, Request\|id, REGISTERED.Registration\|id, Details\|dict, CALL.Arguments\|list, CALL.ArgumentsKw\|dict]
	1632	*/
	1633	static void wamp_proc_invocation_state(wamp_state_t *s, jsonsl_action_t action,
	1634	struct jsonsl_state_st state, const char buf)
	1635	{
	1636	switch (s->prmst) {
	1637	case WAMP_PARAM_STATE_REQUEST_ID:
	1638	if ((action == JSONSL_ACTION_POP)
	1639	&& (state->type == JSONSL_T_SPECIAL)) {
	1640	wamp_callee_invocation_request_id(&s->callee, s->jsn_buf);
	1641	s->prmst = WAMP_PARAM_STATE_REGISTRATION_ID;
	1642	s->state = WAMP_PARSE_STATE_ID_PUSH;
	1643	}
	1644	else
	1645	s->state = WAMP_PARSE_STATE_ERROR;
	1646	break;
	1647	case WAMP_PARAM_STATE_REGISTRATION_ID:
	1648	if ((action == JSONSL_ACTION_POP)
	1649	&& (state->type == JSONSL_T_SPECIAL)) {
	1650	wamp_callee_invocation_registration_id(&s->callee, s->jsn_buf);
	1651	s->prmst = WAMP_PARAM_STATE_DETAILS_DICT;
	1652	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1653	}
	1654	else
	1655	s->state = WAMP_PARSE_STATE_ERROR;
	1656	break;
	1657	case WAMP_PARAM_STATE_DETAILS_DICT:
	1658	if (state->level == 2) {
	1659	if ((action == JSONSL_ACTION_POP)
	1660	&& (state->type == JSONSL_T_OBJECT)) {
	1661	wamp_callee_invocation_details(&s->callee, s->jsn_buf);
	1662	s->prmst = WAMP_PARAM_STATE_ARGUMENTS_LIST;
	1663	s->state = WAMP_PARSE_STATE_LIST_PUSH;
	1664	}
	1665	else
	1666	s->state = WAMP_PARSE_STATE_ERROR;
	1667	}
	1668	else {
	1669	wamp_callee_invocation_details_param(&s->callee, action, state, buf);
	1670	}
	1671	break;
	1672	case WAMP_PARAM_STATE_ARGUMENTS_LIST:
	1673	if (state->level == 2) {
	1674	if ((action == JSONSL_ACTION_POP)
	1675	&& (state->type == JSONSL_T_LIST)) {
	1676	wamp_callee_invocation_arguments(&s->callee, s->jsn_buf);
	1677	s->prmst = WAMP_PARAM_STATE_ARGUMENTSKW_DICT;
	1678	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1679	}
	1680	else
	1681	s->state = WAMP_PARSE_STATE_ERROR;
	1682	}
	1683	else {
	1684	wamp_callee_invocation_arguments_param(&s->callee, action, state, buf);
	1685	}
	1686	break;
	1687	case WAMP_PARAM_STATE_ARGUMENTSKW_DICT:
	1688	if (state->level == 2) {
	1689	if ((action == JSONSL_ACTION_POP)
	1690	&& (state->type == JSONSL_T_OBJECT)) {
	1691	wamp_callee_invocation_argumentskw(&s->callee, s->jsn_buf);
	1692	s->prmst = WAMP_PARAM_STATE_NONE;
	1693	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1694	}
	1695	else
	1696	s->state = WAMP_PARSE_STATE_ERROR;
	1697	}
	1698	else {
	1699	wamp_callee_invocation_argumentskw_param(&s->callee, action, state, buf);
	1700	}
	1701	break;
	1702	default:
	1703	s->state = WAMP_PARSE_STATE_ERROR;
	1704	break;
	1705	}
	1706	}
	1707
	1708	/*
	1709	* [INTERRUPT, INVOCATION.Request\|id, Options\|dict]
	1710	*/
	1711	static void wamp_proc_interrupt_state(wamp_state_t *s, jsonsl_action_t action,
	1712	struct jsonsl_state_st state, const char buf)
	1713	{
	1714	switch (s->prmst) {
	1715	case WAMP_PARAM_STATE_REQUEST_ID:
	1716	if ((action == JSONSL_ACTION_POP)
	1717	&& (state->type == JSONSL_T_SPECIAL)) {
	1718	wamp_callee_interrupt_request_id(&s->callee, s->jsn_buf);
	1719	s->prmst = WAMP_PARAM_STATE_OPTIONS_DICT;
	1720	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1721	}
	1722	else
	1723	s->state = WAMP_PARSE_STATE_ERROR;
	1724	break;
	1725	case WAMP_PARAM_STATE_OPTIONS_DICT:
	1726	if (state->level == 2) {
	1727	if ((action == JSONSL_ACTION_POP)
	1728	&& (state->type == JSONSL_T_OBJECT)) {
	1729	wamp_callee_interrupt_options(&s->callee, s->jsn_buf);
	1730	s->prmst = WAMP_PARAM_STATE_NONE;
	1731	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1732	}
	1733	else
	1734	s->state = WAMP_PARSE_STATE_ERROR;
	1735	}
	1736	else {
	1737	wamp_callee_interrupt_options_param(&s->callee, action, state, buf);
	1738	}
	1739	break;
	1740	default:
	1741	s->state = WAMP_PARSE_STATE_ERROR;
	1742	break;
	1743	}
	1744	}
	1745
	1746	/*
	1747	* [YIELD, INVOCATION.Request\|id, Options\|dict, Arguments\|list, ArgumentsKw\|dict]
	1748	*/
	1749	static void wamp_proc_yield_state(wamp_state_t *s, jsonsl_action_t action,
	1750	struct jsonsl_state_st state, const char buf)
	1751	{
	1752	switch (s->prmst) {
	1753	case WAMP_PARAM_STATE_REQUEST_ID:
	1754	if ((action == JSONSL_ACTION_POP)
	1755	&& (state->type == JSONSL_T_SPECIAL)) {
	1756	wamp_dealer_yield_request_id(&s->dealer, s->jsn_buf);
	1757	s->prmst = WAMP_PARAM_STATE_OPTIONS_DICT;
	1758	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1759	}
	1760	else
	1761	s->state = WAMP_PARSE_STATE_ERROR;
	1762	break;
	1763	case WAMP_PARAM_STATE_OPTIONS_DICT:
	1764	if (state->level == 2) {
	1765	if ((action == JSONSL_ACTION_POP)
	1766	&& (state->type == JSONSL_T_OBJECT)) {
	1767	wamp_dealer_yield_options(&s->dealer, s->jsn_buf);
	1768	s->prmst = WAMP_PARAM_STATE_ARGUMENTS_LIST;
	1769	s->state = WAMP_PARSE_STATE_LIST_PUSH;
	1770	}
	1771	else
	1772	s->state = WAMP_PARSE_STATE_ERROR;
	1773	}
	1774	else {
	1775	wamp_dealer_yield_options_param(&s->dealer, action, state, buf);
	1776	}
	1777	break;
	1778	case WAMP_PARAM_STATE_ARGUMENTS_LIST:
	1779	if (state->level == 2) {
	1780	if ((action == JSONSL_ACTION_POP)
	1781	&& (state->type == JSONSL_T_LIST)) {
	1782	wamp_dealer_yield_arguments(&s->dealer, s->jsn_buf);
	1783	s->prmst = WAMP_PARAM_STATE_ARGUMENTSKW_DICT;
	1784	s->state = WAMP_PARSE_STATE_DICT_PUSH;
	1785	}
	1786	else
	1787	s->state = WAMP_PARSE_STATE_ERROR;
	1788	}
	1789	else {
	1790	wamp_dealer_yield_arguments_param(&s->dealer, action, state, buf);
	1791	}
	1792	break;
	1793	case WAMP_PARAM_STATE_ARGUMENTSKW_DICT:
	1794	if (state->level == 2) {
	1795	if ((action == JSONSL_ACTION_POP)
	1796	&& (state->type == JSONSL_T_OBJECT)) {
	1797	wamp_dealer_yield_argumentskw(&s->dealer, s->jsn_buf);
	1798	s->prmst = WAMP_PARAM_STATE_NONE;
	1799	s->state = WAMP_PARSE_STATE_NOMORE_PARAM;
	1800	}
	1801	else
	1802	s->state = WAMP_PARSE_STATE_ERROR;
	1803	}
	1804	else {
	1805	wamp_dealer_yield_argumentskw_param(&s->dealer, action, state, buf);
	1806	}
	1807	break;
	1808	default:
	1809	s->state = WAMP_PARSE_STATE_ERROR;
	1810	break;
	1811	}
	1812	}
	1813
	1814	void wamp_error(wamp_state_t *s)
	1815	{
	1816	}
	1817
	1818	void wamp_error_type(wamp_state_t s, const char value)
	1819	{
	1820	}
	1821
	1822	void wamp_error_request_id(wamp_state_t s, const char value)
	1823	{
	1824	}
	1825
	1826	void wamp_error_details(wamp_state_t s, const char value)
	1827	{
	1828	}
	1829
	1830	void wamp_error_details_param(wamp_state_t *s, jsonsl_action_t action,
	1831	struct jsonsl_state_st state, const char buf)
	1832	{
	1833	}
	1834
	1835	void wamp_error_uri(wamp_state_t s, const char value)
	1836	{
	1837	}
	1838
	1839	void wamp_error_arguments(wamp_state_t s, const char value)
	1840	{
	1841	}
	1842
	1843	void wamp_error_arguments_param(wamp_state_t *s, jsonsl_action_t action,
	1844	struct jsonsl_state_st state, const char buf)
	1845	{
	1846	}
	1847
	1848	void wamp_error_argumentskw(wamp_state_t s, const char value)
	1849	{
	1850	}
	1851
	1852	void wamp_error_argumentskw_param(wamp_state_t *s, jsonsl_action_t action,
	1853	struct jsonsl_state_st state, const char buf)
	1854	{
	1855	}
	1856
	1857	static void wamp_error_close(wamp_state_t *s)
	1858	{
	1859	}
	1860
	1861	static void wamp_param_handler(struct wamp_state *s, jsonsl_action_t action,
	1862	wamp_param_state_t param, const char *value)
	1863	{
	1864	}
	1865
	1866	ER wamp_send_error_res(struct wamp_state s, wamp_code_t code, int requestId, const char error)
	1867	{
	1868	ECN_FBS_ID buf;
	1869	ECN_FBS_SSIZE_T pos = 0;
	1870	ER ret;
	1871
	1872	ret = _ecn_fbs_cre(1, &buf);
	1873	if (ret != E_OK) {
	1874	syslog(LOG_WARNING, "_ecn_fbs_cre() result = %d", ret);
	1875	return ret;
	1876	}
	1877
	1878	ret = fbs_printf(buf, &pos, "[8,%d,%d,{},\"%s\"]", (int)code, requestId, error);
	1879	if (ret != E_OK) {
	1880	syslog(LOG_WARNING, "fbs_printf() result = %d", ret);
	1881	_ecn_fbs_del(buf);
	1882	return ret;
	1883	}
	1884
	1885	return main_send_message(buf, s->wbsid);
	1886	}

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

Download in other formats:

Original Format