1 /*********************************************************************************************************
2 * Software License Agreement (BSD License) *
3 * Author: Sebastien Decugis <sdecugis@freediameter.net> *
4 * *
5 * Copyright (c) 2013, WIDE Project and NICT *
6 * All rights reserved. *
7 * *
8 * Redistribution and use of this software in source and binary forms, with or without modification, are *
9 * permitted provided that the following conditions are met: *
10 * *
11 * * Redistributions of source code must retain the above *
12 * copyright notice, this list of conditions and the *
13 * following disclaimer. *
14 * *
15 * * Redistributions in binary form must reproduce the above *
16 * copyright notice, this list of conditions and the *
17 * following disclaimer in the documentation and/or other *
18 * materials provided with the distribution. *
19 * *
20 * * Neither the name of the WIDE Project or NICT nor the *
21 * names of its contributors may be used to endorse or *
22 * promote products derived from this software without *
23 * specific prior written permission of WIDE Project and *
24 * NICT. *
25 * *
26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED *
27 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
28 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR *
29 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT *
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS *
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR *
32 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF *
33 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
34 *********************************************************************************************************/
35
36 /* Do not include this directly, use dbg_interactive.i instead */
37
38 /****** SESSIONS *********/
39
40 %{
41 struct sess_state {
42 PyObject * pystate;
43 };
44
45 /* call it (might be called from a different thread than the interpreter, when session times out) */
call_the_python_cleanup_callback(struct sess_state * state,os0_t sid,void * cb)46 static void call_the_python_cleanup_callback(struct sess_state * state, os0_t sid, void * cb) {
47 PyObject *result;
48 if (!cb) {
49 fd_log_debug("Internal error: missing callback object!");
50 return;
51 }
52
53 /* Call the function */
54 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
55 result = PyObject_CallFunction((PyObject *)cb, "(Os)", state, sid);
56 Py_XDECREF(result);
57 SWIG_PYTHON_THREAD_END_BLOCK;
58 return;
59 }
60 %}
61
62 struct session_handler {
63 };
64
65 %nodefaultctor session_handler;
66 %extend session_handler {
session_handler(PyObject * PyCb)67 session_handler(PyObject * PyCb) {
68 struct session_handler * hdl = NULL;
69 int ret;
70
71 Py_XINCREF(PyCb);
72
73 ret = fd_sess_handler_create ( &hdl, call_the_python_cleanup_callback, NULL, PyCb );
74 if (ret != 0) {
75 DI_ERROR(ret, NULL, NULL);
76 return NULL;
77 }
78 return hdl;
79 }
~session_handler()80 ~session_handler() {
81 struct session_handler * hdl = self;
82 PyObject * cb = NULL;
83
84 int ret = fd_sess_handler_destroy(&hdl, (void *)&cb);
85 if (ret != 0) {
86 DI_ERROR(ret, NULL, NULL);
87 }
88 /* Now free the callback */
89 Py_XDECREF(cb);
90 return;
91 }
dump()92 void dump() {
93 char * buf = NULL;
94 size_t len;
95 printf("%s", fd_sess_dump_hdl(&buf, &len, NULL, $self));
96 free(buf);
97 }
98 }
99
100
101 struct session {
102 };
103
104 %extend session {
105 /* The first two versions create a new session string. The third one allow to use an existing string. */
session()106 session() {
107 int ret;
108 struct session * s = NULL;
109 ret = fd_sess_new(&s, fd_g_config->cnf_diamid, fd_g_config->cnf_diamid_len, (os0_t)"dbg_interactive", CONSTSTRLEN("dbg_interactive"));
110 if (ret != 0) {
111 DI_ERROR(ret, NULL, NULL);
112 return NULL;
113 }
114 return s;
115 }
session(char * diamid,char * STRING,size_t LENGTH)116 session(char * diamid, char * STRING, size_t LENGTH) {
117 int ret;
118 struct session * s = NULL;
119 ret = fd_sess_new(&s, diamid, 0, (os0_t)STRING, LENGTH);
120 if (ret != 0) {
121 DI_ERROR(ret, NULL, NULL);
122 return NULL;
123 }
124 return s;
125 }
session(char * STRING,size_t LENGTH)126 session(char * STRING, size_t LENGTH) {
127 int ret, n;
128 struct session * s = NULL;
129 ret = fd_sess_fromsid((os0_t)STRING, LENGTH, &s, &n);
130 if (ret != 0) {
131 DI_ERROR(ret, NULL, NULL);
132 return NULL;
133 }
134 /* When defining n as OUTPUT parameter, we get something strange... Use fd_sess_fromsid if you need it */
135 #if 0
136 if (n) {
137 fd_log_debug("A new session has been created");
138 } else {
139 fd_log_debug("A session with same id already existed");
140 }
141 #endif /* 0 */
142
143 return s;
144 }
~session()145 ~session() {
146 struct session * s = self;
147 int ret = fd_sess_reclaim(&s);
148 if (ret != 0) {
149 DI_ERROR(ret, NULL, NULL);
150 }
151 return;
152 }
153
154 %cstring_output_allocate_size(char ** outsid, size_t * sidlen, /* do not free */);
getsid(char ** outsid,size_t * sidlen)155 void getsid(char ** outsid, size_t * sidlen) {
156 int ret;
157 ret = fd_sess_getsid( $self, (void *)outsid, sidlen);
158 if (ret != 0) {
159 DI_ERROR(ret, NULL, NULL);
160 return;
161 }
162 return;
163 }
settimeout(long seconds)164 void settimeout(long seconds) {
165 struct timespec timeout;
166 int ret;
167 clock_gettime(CLOCK_REALTIME, &timeout);
168 timeout.tv_sec += seconds;
169 ret = fd_sess_settimeout( $self, &timeout );
170 if (ret != 0) {
171 DI_ERROR(ret, NULL, NULL);
172 }
173 }
dump()174 void dump() {
175 char * buf = NULL;
176 size_t len = 0;
177 printf("%s", fd_sess_dump(&buf, &len, NULL, $self, 1) );
178 free(buf);
179 }
store(struct session_handler * handler,PyObject * DISOWN)180 void store(struct session_handler * handler, PyObject * DISOWN) {
181 int ret;
182 struct sess_state * st = NULL;
183 st = malloc(sizeof(struct sess_state));
184 st->pystate = DISOWN;
185 Py_XINCREF(DISOWN);
186 ret = fd_sess_state_store(handler, $self, (void *) &st);
187 if (ret != 0) {
188 DI_ERROR(ret, NULL, NULL);
189 }
190 }
191 %newobject retrieve;
retrieve(struct session_handler * handler)192 PyObject * retrieve(struct session_handler * handler) {
193 int ret;
194 struct sess_state * st = NULL;
195 PyObject * state = NULL;
196 ret = fd_sess_state_retrieve(handler, $self, (void *) &st);
197 if (ret != 0) {
198 DI_ERROR(ret, NULL, NULL);
199 return NULL;
200 }
201 if (st == NULL) {
202 Py_INCREF(Py_None);
203 return Py_None;
204 }
205 state = st->pystate;
206 free(st);
207 return state;
208 }
209 }
210
211