← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libprelude/trusty

« back to all changes in this revision

Viewing changes to bindings/libprelude_perl.i

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2009-04-29 11:31:50 UTC
  • mfrom: (1.1.12 upstream) (2.1.4 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090429113150-qw9oxc1e50ldljck
Tags: 0.9.22-2ubuntu1
* Merge from debian unstable, remaining changes:
  - Build-Depend on libltdl7-dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bindings/libprelude_perl.i
1
 
/*****
2
 
*
3
 
* Copyright (C) 2003, 2004, 2005 PreludeIDS Technologies. All Rights Reserved.
4
 
* Author: Nicolas Delon <nicolas.delon@prelude-ids.com>
5
 
*
6
 
* This file is part of the Prelude library.
7
 
*
8
 
* This program is free software; you can redistribute it and/or modify
9
 
* it under the terms of the GNU General Public License as published by 
10
 
* the Free Software Foundation; either version 2, or (at your option)
11
 
* any later version.
12
 
*
13
 
* This program is distributed in the hope that it will be useful,
14
 
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
 
* GNU General Public License for more details.
17
 
*
18
 
* You should have received a copy of the GNU General Public License
19
 
* along with this program; see the file COPYING.  If not, write to
20
 
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
21
 
*
22
 
*****/
23
 
 
24
 
%module Prelude
25
 
 
26
 
%{
27
 
void swig_perl_raise_error(int error)
28
 
{
29
 
        char buf[1024];
30
 
 
31
 
        snprintf(buf, sizeof(buf), "Prelude error - %s: %s", prelude_strsource(error), prelude_strerror(error));
32
 
        croak(buf);
33
 
}
34
 
 
35
 
 
36
 
SV *swig_perl_string(prelude_string_t *string)
37
 
{
38
 
        if ( string ) {
39
 
                return newSVpv(prelude_string_get_string(string), prelude_string_get_len(string));
40
 
        } else {
41
 
                SvREFCNT_inc (& PL_sv_undef);
42
 
                return &PL_sv_undef;
43
 
        }
44
 
}
45
 
 
46
 
 
47
 
SV *swig_perl_data(idmef_data_t *data)
48
 
{
49
 
        switch ( idmef_data_get_type(data) ) {
50
 
        case IDMEF_DATA_TYPE_CHAR: 
51
 
        case IDMEF_DATA_TYPE_BYTE:
52
 
                return newSVpv(idmef_data_get_data(data), 1);
53
 
 
54
 
        case IDMEF_DATA_TYPE_CHAR_STRING: 
55
 
                return newSVpv(idmef_data_get_data(data), idmef_data_get_len(data) - 1);
56
 
 
57
 
        case IDMEF_DATA_TYPE_BYTE_STRING:
58
 
                return newSVpv(idmef_data_get_data(data), idmef_data_get_len(data));
59
 
 
60
 
        case IDMEF_DATA_TYPE_UINT32:
61
 
                return newSVpvf("%d", idmef_data_get_uint32(data));
62
 
 
63
 
        case IDMEF_DATA_TYPE_UINT64:
64
 
                return newSVpvf("%" PRELUDE_PRIu64, idmef_data_get_uint64(data));
65
 
 
66
 
        case IDMEF_DATA_TYPE_FLOAT:
67
 
                return newSVpvf("%hf", idmef_data_get_float(data));
68
 
 
69
 
        default:
70
 
                SvREFCNT_inc (& PL_sv_undef);
71
 
                return &PL_sv_undef;
72
 
        }
73
 
}
74
 
 
75
 
%}
76
 
 
77
 
 
78
 
/* This typemap is used to allow NULL pointers in _get_next_* functions
79
 
 */
80
 
%typemap(in) SWIGTYPE *LISTEDPARAM {
81
 
        if ( ! SvOK($input) ) {
82
 
                $1 = NULL;
83
 
        } else {
84
 
                if ( SWIG_ConvertPtr($input, (void **)&$1, $1_descriptor, 0) ) {
85
 
                        croak("Expected type $1_type for argument $argnum.");
86
 
                        return;
87
 
                }
88
 
        }
89
 
}
90
 
 
91
 
 
92
 
%typemap(in) char **argv {
93
 
        AV *tempav;
94
 
        I32 len;
95
 
        int i;
96
 
        SV  **tv;
97
 
 
98
 
        if ( ! SvROK($input) )
99
 
            croak("Argument $argnum is not a reference.");
100
 
 
101
 
        if ( SvTYPE(SvRV($input)) != SVt_PVAV )
102
 
            croak("Argument $argnum is not an array.");
103
 
 
104
 
        tempav = (AV*) SvRV($input);
105
 
        len = av_len(tempav);
106
 
        $1 = (char **) malloc((len+2)*sizeof(char *));
107
 
        if ( ! $1 )
108
 
                croak("out of memory\n");
109
 
        for (i = 0; i <= len; i++) {
110
 
            tv = av_fetch(tempav, i, 0);        
111
 
            SvREFCNT_inc(*tv);
112
 
            $1[i] = (char *) SvPV_nolen(*tv);
113
 
        }
114
 
        $1[i] = NULL;
115
 
};
116
 
 
117
 
 
118
 
 
119
 
%typemap(freearg) char **argv {
120
 
        free($1);
121
 
};
122
 
 
123
 
 
124
 
 
125
 
 
126
 
/**
127
 
 * Prelude specific typemaps
128
 
 */
129
 
%typemap(in) (char *data, size_t len) {
130
 
        $1 = SvPV_nolen($input);
131
 
        $2 = SvCUR($input);
132
 
};
133
 
 
134
 
%typemap(in) (const char *data, size_t len) {
135
 
        $1 = SvPV_nolen($input);
136
 
        $2 = SvCUR($input);
137
 
};
138
 
 
139
 
%typemap(in) (unsigned char *data, size_t len) {
140
 
        $1 = (unsigned char *) SvPV_nolen($input);
141
 
        $2 = SvCUR($input);
142
 
};
143
 
 
144
 
%typemap(in) (const unsigned char *data, size_t len) {
145
 
        $1 = (unsigned char *) SvPV_nolen($input);
146
 
        $2 = SvCUR($input);
147
 
};
148
 
 
149
 
%typemap(in) (const void *data, size_t len) {
150
 
        $1 = SvPV_nolen($input);
151
 
        $2 = SvCUR($input);
152
 
};
153
 
 
154
 
 
155
 
%typemap(in) (uint64_t *target_id, size_t size) {
156
 
        int i;
157
 
        AV *av;
158
 
        SV **sv;
159
 
 
160
 
        if ( ! (SvROK($input) && SvTYPE(SvRV($input)) == SVt_PVAV) )
161
 
                croak("Argument $argnum is not an array.");
162
 
        
163
 
        av = (AV *) SvRV($input);
164
 
 
165
 
        $2 = av_len(av) + 1; /* av_len returns the highest index of the array NOT the len of the array  */
166
 
        $1 = malloc($2 * sizeof (uint64_t));
167
 
        for ( i = 0; i < $2; i++ ) {
168
 
                sv = av_fetch(av, i, 0);
169
 
                $1[i] = strtoull(SvPV_nolen(*sv), NULL, 0);
170
 
        }
171
 
};
172
 
 
173
 
%typemap(freearg) (uint64_t *target_id, size_t size) {
174
 
        free($1);
175
 
};
176
 
 
177
 
%typemap(out) int {
178
 
        $result = newSViv($1);
179
 
        argvi++;
180
 
};
181
 
 
182
 
%typemap(out) INTPOINTER * {
183
 
        if ( $1 != NULL ) {
184
 
                $result = newSViv(*$1);
185
 
        } else {
186
 
                SvREFCNT_inc (& PL_sv_undef);
187
 
                $result = &PL_sv_undef;
188
 
        }
189
 
}
190
 
 
191
 
%typemap(out) UINTPOINTER * {
192
 
        if ( $1 != NULL ) {
193
 
                $result = newSVuv(*$1);
194
 
        } else {
195
 
                SvREFCNT_inc (& PL_sv_undef);
196
 
                $result = &PL_sv_undef;
197
 
        }
198
 
}
199
 
 
200
 
%typemap(out) INT64POINTER * {
201
 
        if ( $1 != NULL ) {
202
 
                $result = newSViv(*$1);
203
 
        } else {
204
 
                SvREFCNT_inc (& PL_sv_undef);
205
 
                $result = &PL_sv_undef;
206
 
        }
207
 
}
208
 
 
209
 
%typemap(out) UINT64POINTER * {
210
 
        if ( $1 != NULL ) {
211
 
                $result = newSVuv(*$1);
212
 
        } else {
213
 
                SvREFCNT_inc (& PL_sv_undef);
214
 
                $result = &PL_sv_undef;
215
 
        }
216
 
}
217
 
 
218
 
 
219
 
 
220
 
%typemap(argout) (uint64_t *source_id, uint32_t *request_id, void **value) {
221
 
        int ret = SvIV($result);
222
 
 
223
 
        XPUSHs(sv_2mortal(newSVpvf("%" PRELUDE_PRIu64, *$1)));
224
 
        XPUSHs(sv_2mortal(newSVuv(*$2)));
225
 
        XPUSHs(sv_2mortal(newSViv(ret)));
226
 
 
227
 
        if ( *$3 ) {
228
 
                switch ( ret ) {
229
 
                case PRELUDE_OPTION_REPLY_TYPE_LIST:
230
 
                        XPUSHs(sv_2mortal(SWIG_NewPointerObj((void *) * $3, SWIG_TypeQuery("prelude_option_t *"), 0)));
231
 
                        break;
232
 
                default:
233
 
                        XPUSHs(sv_2mortal(newSVpv(*$3, strlen(*$3))));
234
 
                        break;
235
 
                }
236
 
        } else {
237
 
                SvREFCNT_inc (& PL_sv_undef);
238
 
                XPUSHs(&PL_sv_undef);
239
 
        }
240
 
};
241
 
 
242
 
 
243
 
%typemap(in) int *argc (int tmp) {
244
 
        tmp = SvIV($input);
245
 
        $1 = &tmp;
246
 
};
247
 
 
248
 
 
249
 
%typemap(in) prelude_string_t * {
250
 
        int ret;
251
 
        char *str;
252
 
        STRLEN len;
253
 
 
254
 
        str = SvPV($input, len);
255
 
        
256
 
        ret = prelude_string_new_dup_fast(&($1), str, len);
257
 
        if ( ret < 0 ) {
258
 
                swig_perl_raise_error(ret);
259
 
                return;
260
 
        }
261
 
};
262
 
 
263
 
 
264
 
%typemap(out) prelude_string_t * {
265
 
        $result = swig_perl_string($1);
266
 
        argvi++;
267
 
};
268
 
 
269
 
 
270
 
%typemap(out) idmef_data_t * {
271
 
        $result = swig_perl_data($1);
272
 
        argvi++;
273
 
};
274
 
 
275
 
 
276
 
%typemap(out) void * idmef_value_get_object {
277
 
        void *swig_type;
278
 
 
279
 
        swig_type = swig_idmef_value_get_descriptor(arg1);
280
 
        if ( ! swig_type ) {
281
 
                SvREFCNT_inc (& PL_sv_undef);
282
 
                $result = &PL_sv_undef;
283
 
        } else {
284
 
                $result = SWIG_NewPointerObj($1, swig_type, 0);
285
 
        }
286
 
 
287
 
        argvi++;
288
 
};
289
 
 
290
 
 
291
 
%clear idmef_value_t **ret;
292
 
%typemap(argout) idmef_value_t **ret {
293
 
 
294
 
        if ( ! SvROK($input) ) {
295
 
                croak("Argument $argnum is not a reference.");
296
 
                return;
297
 
        }
298
 
 
299
 
        if ( result == 0 ) {
300
 
                SvREFCNT_inc (& PL_sv_undef);
301
 
                $result = &PL_sv_undef;
302
 
 
303
 
        } else if ( result > 0 ) {
304
 
                SV *sv;
305
 
 
306
 
                sv = SvRV($input);
307
 
                sv_setsv(sv, SWIG_NewPointerObj((void *) * $1, $*1_descriptor, 0));
308
 
        }
309
 
};
310
 
 
311
 
 
312
 
%typemap(in, numinputs=0) prelude_string_t *out {
313
 
        int ret;
314
 
        
315
 
        ret = prelude_string_new(&($1));
316
 
        if ( ret < 0 ) {
317
 
                swig_perl_raise_error(ret);
318
 
                return;
319
 
        }
320
 
};
321
 
 
322
 
 
323
 
%typemap(argout) prelude_string_t *out {
324
 
        if ( result >= 0 ) {
325
 
                $result = newSVpv(prelude_string_get_string($1), prelude_string_get_len($1));
326
 
                argvi++;
327
 
        }
328
 
 
329
 
        prelude_string_destroy($1);
330
 
};
331
 
 
332
 
 
333
 
%typemap(in) prelude_msg_t **outmsg ($*1_type tmp) {
334
 
        tmp = NULL;
335
 
        $1 = ($1_ltype) &tmp;
336
 
};
337
 
 
338
 
 
339
 
%typemap(in) prelude_connection_t **outconn ($*1_type tmp) {
340
 
        tmp = NULL;
341
 
        $1 = ($1_ltype) &tmp;
342
 
};
343
 
 
344
 
 
345
 
%typemap(in) SWIGTYPE **OUTPARAM ($*1_type tmp) {
346
 
        $1 = ($1_ltype) &tmp;
347
 
};
348
 
 
349
 
 
350
 
 
351
 
%typemap(argout) SWIGTYPE **OUTPARAM {
352
 
        SV *sv;
353
 
        
354
 
        if ( result >= 0 ) {
355
 
                if ( ! SvROK($input) ) {
356
 
                        croak("Argument $argnum is not a reference.");
357
 
                        return;
358
 
                }
359
 
 
360
 
                sv = SvRV($input);
361
 
                sv_setsv(sv, SWIG_NewPointerObj((void *) * $1, $*1_descriptor, 0));
362
 
        }
363
 
};
364
 
 
365
 
 
366
 
%typemap(in) SWIGTYPE *INPARAM {
367
 
        if ( ! SvROK($input) ) {
368
 
                croak("Argument $argnum is null.");
369
 
                return;
370
 
        }
371
 
 
372
 
        if ( SWIG_ConvertPtr($input, (void **)&arg$argnum, $1_descriptor, 0) ) {
373
 
                croak("Expected type $1_type for argument $argnum.");
374
 
                return;
375
 
        }
376
 
}