implement modifying channel model algo while running, complete function freeing a model

common/utils/telnetsrv/telnetsrv.c

@@ -508,7 +508,7 @@ int process_command(char *buf) {
         }
 
         rt= CMDSTATUS_FOUND;
-      } else if (strncasecmp(cmd,"get",3) == 0 || strncasecmp(cmd,"set",3) == 0) {
+      } else if (strcasecmp(cmd,"get") == 0 || strcasecmp(cmd,"set") == 0) {
         rt= setgetvar(i,cmd[0],cmdb);
       } else {
         for (k=0 ; telnetparams.CmdParsers[i].cmd[k].cmdfunc != NULL ; k++) {
@@ -516,7 +516,7 @@ int process_command(char *buf) {
           	if (telnetparams.CmdParsers[i].cmd[k].qptr != NULL) {
           		notifiedFIFO_elt_t *msg =newNotifiedFIFO_elt(sizeof(telnetsrv_qmsg_t),0,NULL,NULL);
           		telnetsrv_qmsg_t *cmddata=NotifiedFifoData(msg);
-          		cmddata->cmdfunc=telnetparams.CmdParsers[i].cmd[k].cmdfunc;
+          		cmddata->cmdfunc=(qcmdfunc_t)telnetparams.CmdParsers[i].cmd[k].cmdfunc;
           	    cmddata->prnt=client_printf;
           	    cmddata->debug=telnetparams.telnetdbg;
           		cmddata->cmdbuff=strdup(cmdb);
@@ -684,12 +684,12 @@ void run_telnetsrv(void) {
   return;
 }
 
-void poll_telnetcmdq(void *qid) {
+void poll_telnetcmdq(void *qid, void *arg) {
 	notifiedFIFO_elt_t *msg = pollNotifiedFIFO((notifiedFIFO_t *)qid);
 	
 	if (msg != NULL) {
 	  telnetsrv_qmsg_t *msgdata=NotifiedFifoData(msg);
-	  msgdata->cmdfunc(msgdata->cmdbuff,msgdata->debug,msgdata->prnt);
+	  msgdata->cmdfunc(msgdata->cmdbuff,msgdata->debug,msgdata->prnt,arg);
 	  free(msgdata->cmdbuff);
 	  delNotifiedFIFO_elt(msg);
 	}
@@ -826,8 +826,10 @@ int  telnetsrv_checkbuildver(char *mainexec_buildversion, char **shlib_buildvers
 }
 
 int telnetsrv_getfarray(loader_shlibfunc_t  **farray) {
-  *farray=malloc(sizeof(loader_shlibfunc_t));
+  *farray=malloc(sizeof(loader_shlibfunc_t)*2);
   (*farray)[0].fname=TELNET_ADDCMD_FNAME;
   (*farray)[0].fptr=(int (*)(void) )add_telnetcmd;
-  return 1;
+  (*farray)[1].fname=TELNET_POLLCMDQ_FNAME;
+  (*farray)[1].fptr=(int (*)(void) )poll_telnetcmdq; 
+  return ( 2);
 }

common/utils/telnetsrv/telnetsrv.h

@@ -53,6 +53,7 @@
 /* to add a set of new command to the telnet server shell */
 typedef void(*telnet_printfunc_t)(const char* format, ...);
 typedef int(*cmdfunc_t)(char*, int, telnet_printfunc_t prnt);
+typedef int(*qcmdfunc_t)(char*, int, telnet_printfunc_t prnt,void *arg);
 
 #define TELNETSRV_CMDFLAG_PUSHINTPOOLQ   (1<<0)    // ask the telnet server to push the command in a thread pool queue
 typedef struct cmddef {
@@ -67,7 +68,7 @@ typedef struct cmddef {
 /* structure used to send a command via a message queue to enable */
 /* executing a command in a thread different from the telnet server thread */
 typedef struct telnetsrv_qmsg {
-  cmdfunc_t cmdfunc;
+  qcmdfunc_t cmdfunc;
   telnet_printfunc_t prnt;
   int debug;
   char *cmdbuff;
@@ -144,7 +145,7 @@ VT escape sequence definition, for smarter display....
 #define TELNET_ADDCMD_FNAME "add_telnetcmd"
 #define TELNET_POLLCMDQ_FNAME "poll_telnetcmdq"
 typedef int(*add_telnetcmd_func_t)(char *, telnetshell_vardef_t *, telnetshell_cmddef_t *);
-typedef void(*poll_telnetcmdq_func_t)(void *qid);
+typedef void(*poll_telnetcmdq_func_t)(void *qid,void *arg);
 #ifdef TELNETSERVERCODE
 int add_telnetcmd(char *modulename, telnetshell_vardef_t *var, telnetshell_cmddef_t *cmd);
 void set_sched(pthread_t tid, int pid,int priority);

openair1/SIMULATION/TOOLS/random_channel.c

@@ -93,6 +93,7 @@ void fill_channel_desc(channel_desc_t *chan_desc,
 
   if (delays==NULL) {
     chan_desc->delays = (double *) malloc(nb_taps*sizeof(double));
+    chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_DELAY ;
     delta_tau = Td/nb_taps;
 
     for (i=0; i<nb_taps; i++)
@@ -134,10 +135,9 @@ void fill_channel_desc(channel_desc_t *chan_desc,
 
   if (R_sqrt == NULL) {
     chan_desc->R_sqrt         = (struct complex **) calloc(nb_taps,sizeof(struct complex *));
-
+    chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_NTAPS ;
     for (i = 0; i<nb_taps; i++) {
       chan_desc->R_sqrt[i]    = (struct complex *) calloc(nb_tx*nb_rx*nb_tx*nb_rx,sizeof(struct complex));      
-
       for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
         chan_desc->R_sqrt[i][j].x = 1.0;
         chan_desc->R_sqrt[i][j].y = 0.0;
@@ -285,7 +285,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
                                      double forgetting_factor,              
                                      int32_t channel_offset,
                                      double path_loss_dB) {
-  channel_desc_t *chan_desc = (channel_desc_t *)malloc(sizeof(channel_desc_t));
+  channel_desc_t *chan_desc = (channel_desc_t *)calloc(1,sizeof(channel_desc_t));
   for(int i=0; i<max_chan;i++) {
   	  if (defined_channels[i] == NULL) {
   	  	  defined_channels[i]=chan_desc;                             
@@ -330,7 +330,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;         
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*scm_c_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -368,6 +368,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
         for (i = 0; i<6; i++)
           chan_desc->R_sqrt[i] = (struct complex *) &R12_sqrt[i][0];
       } else {
+      	chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6 ; 
         for (i = 0; i<6; i++) {
           chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
            
@@ -389,7 +390,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*scm_c_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -427,6 +428,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
         for (i = 0; i<6; i++)
           chan_desc->R_sqrt[i] = (struct complex *) &R12_sqrt[i][0];
       } else {
+      	chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6 ;
         for (i = 0; i<6; i++) {
           chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
 
@@ -447,7 +449,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*epa_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -480,7 +482,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
           chan_desc->R_sqrt[i] = (struct complex *) &R22_sqrt[i][0];
       } else {
         chan_desc->R_sqrt         = (struct complex **) malloc(6*sizeof(struct complex **));
-
+        chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6 ;
         for (i = 0; i<6; i++) {
           chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
 
@@ -501,7 +503,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*epa_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -555,7 +557,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*epa_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -609,7 +611,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+       chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*epa_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -663,7 +665,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*eva_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -696,7 +698,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
           chan_desc->R_sqrt[i] = (struct complex *) &R22_sqrt[i][0];
       } else {
         chan_desc->R_sqrt         = (struct complex **) malloc(6*sizeof(struct complex **));
-
+        chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6 ;
         for (i = 0; i<6; i++) { 
           chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
 
@@ -717,7 +719,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*etu_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -750,7 +752,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
           chan_desc->R_sqrt[i] = (struct complex *) &R22_sqrt[i][0];
       } else {
         chan_desc->R_sqrt         = (struct complex **) malloc(6*sizeof(struct complex **));
-
+        chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6 ;
         for (i = 0; i<6; i++) {
           chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
 
@@ -771,7 +773,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       chan_desc->channel_length = (int) (2*chan_desc->sampling_rate*chan_desc->Td + 1 + 2/(M_PI*M_PI)*log(4*M_PI*chan_desc->sampling_rate*chan_desc->Td));
       sum_amps = 0;
       chan_desc->amps           = (double *) malloc(chan_desc->nb_taps*sizeof(double));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_AMPS ;
       for (i = 0; i<chan_desc->nb_taps; i++) {
         chan_desc->amps[i]      = pow(10,.1*mbsfn_amps_dB[i]);
         sum_amps += chan_desc->amps[i];
@@ -798,7 +800,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
         chan_desc->a[i]         = (struct complex *) malloc(nb_tx*nb_rx * sizeof(struct complex));
 
       chan_desc->R_sqrt  = (struct complex **) malloc(6*sizeof(struct complex *));
-
+      chan_desc->free_flags=chan_desc->free_flags|CHANMODEL_FREE_RSQRT_6;
       for (i = 0; i<6; i++) {
         chan_desc->R_sqrt[i]    = (struct complex *) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
 
@@ -1313,9 +1315,35 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
 void free_channel_desc_scm(channel_desc_t *ch) {
   // Must be made cleanly, a lot of leaks...
   defined_channels[ch->chan_idx]=NULL; 
+  if(ch->free_flags&CHANMODEL_FREE_AMPS)
+    free(ch->amps);
+  for (int i = 0; i<ch->nb_tx*ch->nb_rx; i++) { 
+    free(ch->ch[i]);
+    free(ch->chF[i]);
+  }
+            
+  for (int i = 0; i<ch->nb_taps; i++) {
+    free(ch->a[i]);              
+  }   
+  if(ch->free_flags&CHANMODEL_FREE_DELAY)
+    free(ch->delays);  
+  if(ch->free_flags&CHANMODEL_FREE_RSQRT_6)
+    for (int i = 0; i<6; i++)  
+      free(ch->R_sqrt[i]);             
+  if(ch->free_flags&CHANMODEL_FREE_RSQRT_NTAPS)
+    for (int i = 0; i<ch->nb_taps;i++)  
+      free(ch->R_sqrt[i]); 
+  free(ch->R_sqrt);        
+  free(ch->ch); 
+  free(ch->chF);
+  free(ch->a);  
   free(ch);                                          
 }
 
+void set_channeldesc_owner(channel_desc_t *cdesc, uint32_t module_id) {
+	cdesc->module_id=module_id;
+}
+
 int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
   double s;
   int i,k,l,aarx,aatx;
@@ -1522,6 +1550,10 @@ static int channelmod_print_help(char *buff, int debug, telnet_printfunc_t prnt
 
 
 static void display_channelmodel(channel_desc_t *cd,int debug, telnet_printfunc_t prnt) {
+	char *module_id_str[]=MODULEID_STR_INIT;
+	if (cd->module_id != 0) {
+		prnt("model owner: %s\n",module_id_str[cd->module_id]);
+	}
 	prnt("nb_tx: %i    nb_rx: %i    taps: %i bandwidth: %lf    sampling: %lf\n",cd->nb_tx, cd->nb_rx, cd->nb_taps, cd->channel_bandwidth, cd->sampling_rate);
 	prnt("channel length: %i    Max path delay: %lf   ricean fact.: %lf    angle of arrival: %lf (randomized:%s)\n",
 		 cd->channel_length, cd->Td, cd->ricean_factor, cd->aoa, (cd->random_aoa?"Yes":"No"));
@@ -1619,8 +1651,8 @@ static int channelmod_modify_cmd(char *buff, int debug, telnet_printfunc_t prnt)
    
 int modelid_fromname(char *modelname) {                                             
   int modelid=map_str_to_int(channelmod_names,modelname);   
-  AssertFatal(modelid>0,
-              "random_channel.c: Error channel model %s unknown\n",modelname);
+  if (modelid < 0)   
+    LOG_E(OCM,"random_channel.c: Error channel model %s unknown\n",modelname);
   return modelid;
 }
 

openair1/SIMULATION/TOOLS/sim.h

@@ -40,6 +40,16 @@ The present clause specifies several numerical functions for testing of digital
 
 #define NB_SAMPLES_CHANNEL_OFFSET 4
 
+typedef enum {
+  UNSPECIFIED_MODID=0,
+  RFSIMU_MODULEID=1
+} channelmod_moduleid_t;
+#define MODULEID_STR_INIT {"","rfsimulator"}
+
+#define CHANMODEL_FREE_DELAY       1<<0
+#define CHANMODEL_FREE_RSQRT_6     1<<1
+#define CHANMODEL_FREE_RSQRT_NTAPS 1<<2
+#define CHANMODEL_FREE_AMPS        1<<3
 typedef struct {
   ///Number of tx antennas
   uint8_t nb_tx;
@@ -96,6 +106,10 @@ typedef struct {
   unsigned int chan_idx;
   /// id of the channel modeling algorithm
   int modelid;
+  /// identifies channel descriptor owner (the module which created this descriptor)
+  channelmod_moduleid_t module_id;
+  /// flags to properly trigger memory free
+  unsigned int free_flags;
 } channel_desc_t;
 
 typedef struct {
@@ -278,9 +292,18 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
                                      double forgetting_factor,
                                      int32_t channel_offset,
                                      double path_loss_dB);
+/**
+\brief free memory allocated for a model descriptor
+\param ch points to the model, which cannot be used after calling this fuction
+*/
+void free_channel_desc_scm(channel_desc_t *ch);
 
-
-
+/**
+\brief This set the ownerid of a model descriptor, can be later used to check what module created a channel model
+\param cdesc points to the model descriptor
+\param module_id identifies the channel model. should be define as a macro in simu.h
+*/
+void set_channeldesc_owner(channel_desc_t *cdesc, channelmod_moduleid_t module_id);
 /** \fn void random_channel(channel_desc_t *desc)
 \brief This routine generates a random channel response (time domain) according to a tapped delay line model.
 \param desc Pointer to the channel descriptor

targets/ARCH/rfsimulator/simulator.c

@@ -89,9 +89,9 @@ extern RAN_CONTEXT_t RC;
 
 
 
-static int rfsimu_setchanmod_cmd(char *buff, int debug, telnet_printfunc_t prnt);
+static int rfsimu_setchanmod_cmd(char *buff, int debug, telnet_printfunc_t prnt, void *arg);
 static telnetshell_cmddef_t rfsimu_cmdarray[] = {
-  {"setmodel","<model name>",rfsimu_setchanmod_cmd,TELNETSRV_CMDFLAG_PUSHINTPOOLQ},  
+  {"setmodel","<model name>",(cmdfunc_t)rfsimu_setchanmod_cmd,TELNETSRV_CMDFLAG_PUSHINTPOOLQ},  
   {"","",NULL},
 };
 
@@ -185,6 +185,7 @@ void allocCirBuf(rfsimulator_state_t *bridge, int sock) {
                                             bridge->chan_forgetfact, // forgetting_factor
                                             bridge->chan_offset, // maybe used for TA
                                             bridge->chan_pathloss); // path_loss in dB
+    set_channeldesc_owner(ptr->channel_model, RFSIMU_MODULEID);
     random_channel(ptr->channel_model,false);
   }
 }
@@ -311,25 +312,38 @@ void rfsimulator_readconfig(rfsimulator_state_t *rfsimulator) {
     rfsimulator->typeStamp = UE_MAGICDL_FDD;
 }
 
-static int rfsimu_setchanmod_cmd(char *buff, int debug, telnet_printfunc_t prnt) {
+static int rfsimu_setchanmod_cmd(char *buff, int debug, telnet_printfunc_t prnt, void *arg) {
   char *modelname=NULL; 
   int s = sscanf(buff,"%ms\n",&modelname);
+  if (s == 1) {
     int channelmod=modelid_fromname(modelname);
+    if (channelmod<0)
+      prnt("ERROR: model %s unknown\n",modelname);
+    else {
+  	  rfsimulator_state_t *t = (rfsimulator_state_t *)arg;
   	  for (int i=0; i<FD_SETSIZE; i++) {
-/*    if(rfsimulator->buf[i].conn_sock > 0) {
-       channel_desc_t *cm = rfsimulator->buf[i].channel_model;
-
-       rfsimulator->buf[i].channel_model=new_channel_desc_scm(cm->nb_tx,cm->nb_rx,
+        buffer_t *b=&t->buf[i];
+        if (b->conn_sock >= 0 ) {
+          channel_desc_t *newmodel=new_channel_desc_scm(t->tx_num_channels,t->rx_num_channels,
                                                 channelmod,
-                                            cm->sampling_rate,
-                                            cm->channel_bandwidth,
-                                            cm->forgetting_factor, // forgetting_factor
-                                            cm->channel_offset, // maybe used for TA
-                                            cm-> path_loss_dB); // path_loss in dB
-	   free_channel_desc_scm(cm);
-       random_channel(ptr->channel_model,false);	   
-	}	*/
+                                                t->sample_rate,
+                                                t->tx_bw,
+                                                t->chan_forgetfact, // forgetting_factor
+                                                t->chan_offset, // maybe used for TA
+                                                t->chan_pathloss); // path_loss in dB
+          set_channeldesc_owner(newmodel, RFSIMU_MODULEID);
+          random_channel(newmodel,false);
+          channel_desc_t *oldmodel=b->channel_model;
+          b->channel_model=newmodel;
+          free_channel_desc_scm(oldmodel);
+          prnt("New model %s applied to channel connected to sock %d\n",modelname,i);
+        }
+      }
+    }
+  } else {
+  	  prnt("ERROR: no model specified\n");  
   }
+  free(modelname);
   return CMDSTATUS_FOUND;
 }
 
@@ -683,7 +697,8 @@ int rfsimulator_read(openair0_device *device, openair0_timestamp *ptimestamp, vo
       // it seems legacy behavior is: never in UL, each frame in DL
       if (reGenerateChannel)
         random_channel(ptr->channel_model,0);
-      t->poll_telnetcmdq(t->telnetcmd_qid);
+      if (t->poll_telnetcmdq)
+      	  t->poll_telnetcmdq(t->telnetcmd_qid,t);
       for (int a=0; a<nbAnt; a++) {
         if ( ptr->channel_model != NULL ) // apply a channel model
           rxAddInput( ptr->circularBuf, (struct complex16 *) samplesVoid[a],