2 ==================================================================================
3 Copyright (c) 2020 Nokia
4 Copyright (c) 2020 AT&T Intellectual Property.
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
17 ==================================================================================
21 Mnemonic: test_si95_em.c
22 Abstract: This supplies a bunch of dummy SI95 functions which emulate
23 the sending/receiving of data such that modules can be tested
24 without the acutal backing of a network.
26 This module must be directly included to be used.
27 Date: 20 February 2020
28 Author: E. Scott Daniels
32 #include "rmr.h" // we use some of rmr defs in building dummy messages, so we need these
33 #include "rmr_agnostic.h"
35 // ---------------------- emulated SI95 functions ---------------------------
38 #ifndef _em_si // this is the same define as the nng emulation code uses to give warning if both included
41 #include <arpa/inet.h>
44 #include "test_common_em.c" // common emulation needed for all (epoll, gethostname...)
46 // --- some globals --------------------------------------------------------
47 int em_reset_call_flag = 0; // allows a send to turn off the call flag (see em_disable_call_flg())
49 // ------------- emulated message header -----------------------------------
52 This is a copy from agnostic.h. we need to reset flags in some situations
53 so we have to have this, under a different name to avoid disaster.
56 int32_t mtype; // message type ("long" network integer)
57 int32_t plen; // payload length (sender data length in payload)
58 int32_t rmr_ver; // our internal message version number
59 unsigned char xid[RMR_MAX_XID]; // space for user transaction id or somesuch
60 unsigned char sid[RMR_MAX_SID]; // sender ID for return to sender needs
61 unsigned char src[RMR_MAX_SRC]; // name:port of the sender (source)
62 unsigned char meid[RMR_MAX_MEID]; // managed element id.
63 struct timespec ts; // timestamp ???
66 int32_t flags; // HFL_* constants
67 int32_t len0; // length of the RMr header data
68 int32_t len1; // length of the tracing data
69 int32_t len2; // length of data 1 (d1)
70 int32_t len3; // length of data 2 (d2)
71 int32_t sub_id; // subscription id (-1 invalid)
74 unsigned char srcip[RMR_MAX_SRC]; // ip address and port of the source
77 //--------------------------------------------------------------------------
79 These are the current references in the RMR code; all others are internal
80 to the SI portion of the library
83 SIwait( ctx->si_ctx );
84 SIinitialise( SI_OPT_FG ); // FIX ME: si needs to streamline and drop fork/bg stuff
85 SIlistener( ctx->si_ctx, TCP_DEVICE, bind_info )) < 0 ) {
86 SItp_stats( ctx->si_ctx ); // dump some interesting stats
87 SIclose( ctx->nn_sock );
88 SIset_tflags( ctx->si_ctx, SI_TF_FASTACK );
89 SIconnect( si_ctx, conn_info )) < 0 ) {
90 SIsendt( ctx->si_ctx, nn_sock, msg->tp_buf, tot_len )) != SI_OK ) {
93 #define SIEM_BLOCKED 18
94 #define SIEM_ERROR (-1)
97 #define SOCKET_TYPE int // socket representation is different in each transport
99 struct ginfo_blk; // defined in SI things, but must exist here
101 #include "si95/socket_if.h" // need to have the si context more than anything else
104 static void *em_sinew( int type ) {
108 static char *em_sigetname( int sid ) {
112 static int em_siaddress( void *src, void **dest, int type ) {
116 static void em_sibldpoll( struct ginfo_blk* gptr ) {
120 static struct tp_blk *em_siconn_prep( struct ginfo_blk *gptr, int type, char *abuf, int family ) {
125 Caller passing a callback funciton for SI to drive; nothing to do.
127 void *em_cb_data = NULL;
128 static void em_sicbreg( struct ginfo_blk *gptr, int type, int ((*fptr)()), void * dptr ) {
129 if( em_cb_data == NULL ) {
130 fprintf( stderr, "<SIEM> calldback dptr %p saved for type %d\n", dptr, type );
136 static void em_sicbstat( struct ginfo_blk *gptr, int status, int type ) {
140 static int em_siclose( struct ginfo_blk *gptr, int fd ) {
145 If em_send_failures is true, this will fail a small part of the time
146 to simualte connection failures.
148 If the port number is < 1000 it will fail -- allowing for specific,single
151 static int em_next_fd = 0;
152 static int em_siconnect( struct ginfo_blk *gptr, char *abuf ) {
153 static int count = 0;
156 if( em_send_failures && (count++ % 15 == 14) ) {
157 //fprintf( stderr, "<SIEM> siem is failing connect attempt\n\n" );
161 if( (tok = strchr( abuf, ':' )) != NULL && atoi( tok+1 ) < 1000 ) {
162 fprintf( stderr, "<SIEM> siem is emulating connect to (%s) with a failure; port <1000\n", abuf );
166 fprintf( stderr, "<SIEM> siem is emulating connect to (%s) attempt return fd=%d\n", abuf, em_next_fd );
167 if( em_next_fd < 50 ) {
173 static struct tp_blk *em_siestablish( int type, char *abuf, int family ) {
177 static int em_sigenaddr( char *target, int proto, int family, int socktype, struct sockaddr **rap ) {
181 static int em_sigetaddr( struct ginfo_blk *gptr, char *buf ) {
185 static struct tp_blk *em_silisten_prep( int type, char* abuf, int family ) {
190 Called to open a listen port; returns the port fd or -1 on error.
192 static int em_silistener( struct ginfo_blk *gptr, int type, char *abuf ) {
196 static void em_simap_fd( struct ginfo_blk *gptr, int fd, struct tp_blk* tpptr ) {
200 static int em_sinewsession( struct ginfo_blk *gptr, struct tp_blk *tpptr ) {
204 static int em_sipoll( struct ginfo_blk *gptr, int msdelay ) {
208 static int em_sircv( struct ginfo_blk *gptr, int sid, char *buf, int buflen, char *abuf, int delay ) {
212 static void em_sisend( struct ginfo_blk *gptr, struct tp_blk *tpptr ) {
217 Calling this function causes the send emulation to turn off the call
218 flag in the RMR header. Turning that flag off makes the arriving message
219 look as though it might be a response to a call rather than a call itself.
220 This is needed since we loop back messages.
222 static void em_disable_call_flg() {
223 em_reset_call_flag = 1;
224 fprintf( stderr, "<SIEM> reset call flag setting is: %d\n", em_reset_call_flag );
228 Opposite of disable_call_flg; the flag is not touched.
230 static void em_allow_call_flg() {
231 em_reset_call_flag = 0;
232 fprintf( stderr, "<SIEM> reset call flag setting is: %d\n", em_reset_call_flag );
235 // callback prototype to drive to simulate 'receive'
236 static int mt_data_cb( void* datap, int fd, char* buf, int buflen );
239 Emulate sending a message. If the global em_send_failures is set,
240 then every so often we fail with an EAGAIN to drive that part
243 "Send a message" by passing it to the callback if we have a non-nil cb data pointer.
244 We'll divide the data into two to test the concatination of the receiver.
246 static int em_sisendt( struct ginfo_blk *gptr, int fd, char *ubuf, int ulen ) {
247 static int count = 0;
248 static int uss = -1; // ultra short send done
250 if( em_send_failures && ((count++ % 15) == 14) ) {
251 //fprintf( stderr, "<SIEM> sendt is failing send with blocked/again\n\n" );
256 if( em_reset_call_flag ) { // for call testing we need to flip the flag off to see it "return"
259 hdr = (em_mhdr_t *) (ubuf+50); // past the transport header bytes
260 hdr->flags &= ~HFL_CALL_MSG; // flip off the call flag
265 if( em_cb_data != NULL ) {
266 if( uss == 1 ) { // drive the reconstruction where a split in the msg length happens
267 fprintf( stderr, "<SIEM> sendt is queuing ultra short first packet of a two packet sendh len=%d\n", ulen );
268 mt_data_cb( em_cb_data, 0, ubuf, 3 );
269 mt_data_cb( em_cb_data, 0, ubuf+3, ulen - 3 );
272 fprintf( stderr, "<SIEM> sendt is queuing two packets with the callback len=%d\n", ulen );
273 mt_data_cb( em_cb_data, 0, ubuf, 100 );
274 mt_data_cb( em_cb_data, 0, ubuf+100, ulen - 100 );
276 fprintf( stderr, "<SIEM> sendt is queuing one packet with the callback len=%d\n", ulen );
277 mt_data_cb( em_cb_data, 0, ubuf, ulen );
283 //fprintf( stderr, "<SIEM> sendt is returning default reeturn status: %d\n", return_value );
290 static void em_siset_tflags( struct ginfo_blk *gp, int flags ) {
294 static int em_sishow_version( ) {
298 static void em_sishutdown( struct ginfo_blk *gptr ) {
303 This prints some SI stats -- ignore.
305 static void em_sitp_stats( void *vgp ) {
309 static void em_siterm( struct ginfo_blk* gptr, struct tp_blk *tpptr ) {
313 static void em_sitrash( int type, void *bp ) {
318 This will be tricky. Wait receives raw packets from the network
319 and drives the callback(s) which are registered. We'll need to
320 simulate driving the callback with data that spans multiple FDs
321 and has messages split across buffers, but does not block foreaver
322 so the test can continue.
325 For now We'll hard code the RMR callback functions and not
326 try to use what it passes via the register function lest we
327 need to implement all of SI just to run unit tests.
330 Thinking: use rmr's alloc function to alloc a message buffer
331 which we fill in. We can cheat and add the length as RMR does
332 on send, and then split the buffer as we feed it back to the
335 static int em_siwait( struct ginfo_blk *gptr ) {
340 The emulation doesn't use the global info stuff, so alloc something
341 to generate a pointer.
343 static struct ginfo_blk *em_siinitialise( int opts ) {
351 // redefine all SI calls to reference functions here.
352 #define SInew em_sinew
353 #define sigetname em_sigetname
354 #define SIaddress em_siaddress
355 #define SIbldpoll em_sibldpoll
356 #define SIconn_prep em_siconn_prep
357 #define SIcbreg em_sicbreg
358 #define SIcbstat em_sicbstat
359 //#define SIclose em_siclose
360 #define SIconnect em_siconnect
361 #define SIestablish em_siestablish
362 #define SIgenaddr em_sigenaddr
363 #define SIgetaddr em_sigetaddr
364 #define SIlisten_prep em_silisten_prep
365 #define SIlistener em_silistener
366 #define SImap_fd em_simap_fd
367 #define SInewsession em_sinewsession
368 #define SIpoll em_sipoll
369 #define SIrcv em_sircv
370 #define SIsend em_sisend
371 #define SIsendt em_sisendt
372 #define SIset_tflags em_siset_tflags
373 #define SIshow_version em_sishow_version
374 #define SIshutdown em_sishutdown
375 #define SItp_stats em_sitp_stats
376 #define SIterm em_siterm
377 #define SItrash em_sitrash
378 #define SIwait em_siwait
379 #define SIinitialise em_siinitialise