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 static int em_next_fd = 0;
149 static int em_siconnect( struct ginfo_blk *gptr, char *abuf ) {
150 static int count = 0;
152 if( em_send_failures && (count++ % 15 == 14) ) {
153 //fprintf( stderr, "<SIEM> siem is failing connect attempt\n\n" );
157 fprintf( stderr, "<SIEM> siem is emulating connect to (%s) attempt return fd=%d\n", abuf, em_next_fd );
158 if( em_next_fd < 50 ) {
164 static struct tp_blk *em_siestablish( int type, char *abuf, int family ) {
168 static int em_sigenaddr( char *target, int proto, int family, int socktype, struct sockaddr **rap ) {
172 static int em_sigetaddr( struct ginfo_blk *gptr, char *buf ) {
176 static struct tp_blk *em_silisten_prep( struct ginfo_blk *gptr, int type, char* abuf, int family ) {
181 Called to open a listen port; returns the port fd or -1 on error.
183 static int em_silistener( struct ginfo_blk *gptr, int type, char *abuf ) {
187 static void em_simap_fd( struct ginfo_blk *gptr, int fd, struct tp_blk* tpptr ) {
191 static int em_sinewsession( struct ginfo_blk *gptr, struct tp_blk *tpptr ) {
195 static int em_sipoll( struct ginfo_blk *gptr, int msdelay ) {
199 static int em_sircv( struct ginfo_blk *gptr, int sid, char *buf, int buflen, char *abuf, int delay ) {
203 static void em_sisend( struct ginfo_blk *gptr, struct tp_blk *tpptr ) {
208 Calling this function causes the send emulation to turn off the call
209 flag in the RMR header. Turning that flag off makes the arriving message
210 look as though it might be a response to a call rather than a call itself.
211 This is needed since we loop back messages.
213 static void em_disable_call_flg() {
214 em_reset_call_flag = 1;
215 fprintf( stderr, "<SIEM> reset call flag setting is: %d\n", em_reset_call_flag );
219 Opposite of disable_call_flg; the flag is not touched.
221 static void em_allow_call_flg() {
222 em_reset_call_flag = 0;
223 fprintf( stderr, "<SIEM> reset call flag setting is: %d\n", em_reset_call_flag );
226 // callback prototype to drive to simulate 'receive'
227 static int mt_data_cb( void* datap, int fd, char* buf, int buflen );
230 Emulate sending a message. If the global em_send_failures is set,
231 then every so often we fail with an EAGAIN to drive that part
234 "Send a message" by passing it to the callback if we have a non-nil cb data pointer.
235 We'll divide the data into two to test the concatination of the receiver.
237 static int em_sisendt( struct ginfo_blk *gptr, int fd, char *ubuf, int ulen ) {
238 static int count = 0;
239 static int uss = -1; // ultra short send done
241 if( em_send_failures && ((count++ % 15) == 14) ) {
242 //fprintf( stderr, "<SIEM> sendt is failing send with blocked/again\n\n" );
247 if( em_reset_call_flag ) { // for call testing we need to flip the flag off to see it "return"
250 hdr = (em_mhdr_t *) (ubuf+50); // past the transport header bytes
251 hdr->flags &= ~HFL_CALL_MSG; // flip off the call flag
256 if( em_cb_data != NULL ) {
257 if( uss == 1 ) { // drive the reconstruction where a split in the msg length happens
258 fprintf( stderr, "<SIEM> sendt is queuing ultra short first packet of a two packet sendh len=%d\n", ulen );
259 mt_data_cb( em_cb_data, 0, ubuf, 3 );
260 mt_data_cb( em_cb_data, 0, ubuf+3, ulen - 3 );
263 fprintf( stderr, "<SIEM> sendt is queuing two packets with the callback len=%d\n", ulen );
264 mt_data_cb( em_cb_data, 0, ubuf, 100 );
265 mt_data_cb( em_cb_data, 0, ubuf+100, ulen - 100 );
267 fprintf( stderr, "<SIEM> sendt is queuing one packet with the callback len=%d\n", ulen );
268 mt_data_cb( em_cb_data, 0, ubuf, ulen );
274 //fprintf( stderr, "<SIEM> sendt is returning default reeturn status: %d\n", return_value );
281 static void em_siset_tflags( struct ginfo_blk *gp, int flags ) {
285 static int em_sishow_version( ) {
289 static void em_sishutdown( struct ginfo_blk *gptr ) {
294 This prints some SI stats -- ignore.
296 static void em_sitp_stats( void *vgp ) {
300 static void em_siterm( struct ginfo_blk* gptr, struct tp_blk *tpptr ) {
304 static void em_sitrash( int type, void *bp ) {
309 This will be tricky. Wait receives raw packets from the network
310 and drives the callback(s) which are registered. We'll need to
311 simulate driving the callback with data that spans multiple FDs
312 and has messages split across buffers, but does not block foreaver
313 so the test can continue.
316 For now We'll hard code the RMR callback functions and not
317 try to use what it passes via the register function lest we
318 need to implement all of SI just to run unit tests.
321 Thinking: use rmr's alloc function to alloc a message buffer
322 which we fill in. We can cheat and add the length as RMR does
323 on send, and then split the buffer as we feed it back to the
326 static int em_siwait( struct ginfo_blk *gptr ) {
331 The emulation doesn't use the global info stuff, so alloc something
332 to generate a pointer.
334 static struct ginfo_blk *em_siinitialise( int opts ) {
342 // redefine all SI calls to reference functions here.
343 #define SInew em_sinew
344 #define sigetname em_sigetname
345 #define SIaddress em_siaddress
346 #define SIbldpoll em_sibldpoll
347 #define SIconn_prep em_siconn_prep
348 #define SIcbreg em_sicbreg
349 #define SIcbstat em_sicbstat
350 //#define SIclose em_siclose
351 #define SIconnect em_siconnect
352 #define SIestablish em_siestablish
353 #define SIgenaddr em_sigenaddr
354 #define SIgetaddr em_sigetaddr
355 #define SIlisten_prep em_silisten_prep
356 #define SIlistener em_silistener
357 #define SImap_fd em_simap_fd
358 #define SInewsession em_sinewsession
359 #define SIpoll em_sipoll
360 #define SIrcv em_sircv
361 #define SIsend em_sisend
362 #define SIsendt em_sisendt
363 #define SIset_tflags em_siset_tflags
364 #define SIshow_version em_sishow_version
365 #define SIshutdown em_sishutdown
366 #define SItp_stats em_sitp_stats
367 #define SIterm em_siterm
368 #define SItrash em_sitrash
369 #define SIwait em_siwait
370 #define SIinitialise em_siinitialise