source: packages/net/chillispot/patches/150-chillispot-rmtctrl.patch @ 25751

Last change on this file since 25751 was 25751, checked in by jow, 6 years ago

[packages] chillispot: use memset instead of bzero

File size: 57.3 KB
  • src/chilli.c

    a b  
    102102#include "dhcp.h" 
    103103#include "cmdline.h" 
    104104#include "chilli.h" 
     105#include "remotectrl.h" 
    105106 
    106107struct options_t options; 
    107108 
    static int do_sighup = 0; 
    127128/* Forward declarations */ 
    128129int static acct_req(struct app_conn_t *conn, int status_type); 
    129130int static config_radius(); 
     131void admin_disconnect(struct app_conn_t *appconn, int terminateCause); 
     132void admin_authorize(struct app_conn_t *appconn); 
     133int send_acct_head( struct rmt_socket_t *client, struct app_conn_t *appconn); 
     134int send_Connection( struct rmt_socket_t *client, struct app_conn_t *appconn ); 
     135int send_Acct_Setting ( struct rmt_socket_t *client, struct app_conn_t *appconn ); 
     136int send_Accounting( struct rmt_socket_t *client, struct app_conn_t *appconn ); 
    130137 
    131138/* Fireman catches falling childs and eliminates zombies */ 
    132139void static fireman(int signum) {  
    int static leaky_bucket(struct app_conn_ 
    180187  struct timeval timenow; 
    181188  uint64_t timediff; /* In microseconds */ 
    182189  int result = 0; 
    183  
    184190  
    185191  gettimeofday(&timenow, NULL); 
    186192 
    187193  timediff = (timenow.tv_sec - conn->last_time.tv_sec) * ((uint64_t) 1000000); 
    188194  timediff += (timenow.tv_usec - conn->last_time.tv_usec); 
    189195 
    190   /*  if (options.debug) printf("Leaky bucket timediff: %lld, bucketup: %d, bucketdown: %d %d %d\n",  
    191                             timediff, conn->bucketup, conn->bucketdown,  
    192                             octetsup, octetsdown);*/ 
    193  
    194   if (conn->bandwidthmaxup) { 
     196/*    if (options.debug)  
     197                        printf("Leaky bucket timediff: %lld, bucketup: %d, bucketdown: %d %d %d\n", 
     198                                        timediff, conn->bucketup, conn->bucketdown, octetsup, octetsdown); 
     199*/ 
    195200 
     201        if (conn->bandwidthmaxup) { 
    196202    /* Subtract what the leak since last time we visited */ 
    197203    if (conn->bucketup > ((timediff * conn->bandwidthmaxup)/8000000)) { 
    198204      conn->bucketup -= (timediff * conn->bandwidthmaxup) / 8000000; 
    int static leaky_bucket(struct app_conn_ 
    200206    else { 
    201207      conn->bucketup = 0; 
    202208    } 
    203      
     209//    printf("octetsup: %d -> conn->bucketup+octetsup: %d > conn->bucketupsize: %d \n", octetsup, conn->bucketup + octetsup, conn->bucketupsize); 
    204210    if ((conn->bucketup + octetsup) > conn->bucketupsize) { 
    205       /*if (options.debug) printf("Leaky bucket deleting uplink packet\n");*/ 
     211      if (options.debug) printf("Leaky bucket deleting uplink packet\n"); 
    206212      result = -1; 
    207213    } 
    208214    else { 
    int static leaky_bucket(struct app_conn_ 
    217223    else { 
    218224      conn->bucketdown = 0; 
    219225    } 
     226//    printf("octetsdown: %d -> conn->bucketdown+octetsdown: %d > conn->bucketdownsize: %d \n", octetsdown, conn->bucketdown + octetsdown, conn->bucketdownsize); 
    220227     
    221228    if ((conn->bucketdown + octetsdown) > conn->bucketdownsize) { 
    222       /*if (options.debug) printf("Leaky bucket deleting downlink packet\n");*/ 
     229      if (options.debug) printf("Leaky bucket deleting downlink packet\n"); 
    223230      result = -1; 
    224231    } 
    225232    else { 
    int static leaky_bucket(struct app_conn_ 
    233240} 
    234241#endif /* ifndef NO_LEAKY_BUCKET */ 
    235242 
     243 
    236244/* Run external script */ 
    237245 
    238246int set_env(char *name, char *value, int len, struct in_addr *addr, 
    int static process_options(int argc, cha 
    550558    return -1; 
    551559  } 
    552560 
    553   if (cmdline_parser_configfile (args_info.conf_arg, &args_info, 0, 0, 0)) { 
     561        if (cmdline_parser_configfile (args_info.conf_arg, &args_info, 0, 0, 0)) { 
    554562    sys_err(LOG_ERR, __FILE__, __LINE__, 0, 
    555563            "Failed to parse configuration file: %s!",  
    556564            args_info.conf_arg); 
    int static process_options(int argc, cha 
    10561064                       strlen(args_info.macallowed_arg[numargs])))  
    10571065      return -1; 
    10581066  } 
    1059  
     1067  /* remote monitor                                                    */ 
     1068  /* Defaults to net plus 1                                       */ 
     1069  if (!args_info.rmtlisten_arg) 
     1070    options.rmtlisten.s_addr = options.uamlisten.s_addr; 
     1071  else  
     1072                if (!inet_aton(args_info.rmtlisten_arg, &options.rmtlisten)){ 
     1073                        sys_err(LOG_ERR, __FILE__, __LINE__, 0, 
     1074            "Invalid Remote monitor IP address: %s!", args_info.rmtlisten_arg); 
     1075                        return -1; 
     1076                } 
     1077  /* rmtport                                                      */ 
     1078  options.rmtport = args_info.rmtport_arg; 
     1079  options.rmtpasswd = args_info.rmtpasswd_arg; 
     1080  options.bandwidthmaxup = args_info.bandwidthmaxup_arg; 
     1081  options.bandwidthmaxdown = args_info.bandwidthmaxdown_arg; 
    10601082 
    10611083  /* foreground                                                   */ 
    10621084  /* If flag not given run as a daemon                            */ 
    void static reprocess_options(int argc,  
    10951117    memcpy(&options, &options2, sizeof(options)); 
    10961118    return; 
    10971119  } 
    1098  
    10991120  /* Options which we do not allow to be affected */ 
    11001121  /* fg, conf and statedir are not stored in options */ 
    11011122  options.net = options2.net; /* net */ 
    void static reprocess_options(int argc,  
    11231144  options.eapolenable = options2.eapolenable; /* eapolenable */ 
    11241145  options.pidfile = options2.pidfile; /* pidfile */ 
    11251146 
     1147  options.rmtlisten = options2.rmtlisten; /* remote listen */ 
     1148  options.rmtport = options2.rmtport; /* remote port */ 
     1149  options.rmtpasswd = options2.rmtpasswd; /* remote password */ 
     1150 
     1151//  options.bandwidthmaxup = options2.bandwidthmaxup; /* remote password */ 
     1152//  options.bandwidthmaxdown = options2.bandwidthmaxdown; /* remote password */ 
     1153 
    11261154  /* Reinit DHCP parameters */ 
    11271155  (void) dhcp_set(dhcp, (options.debug & DEBUG_DHCP), 
    11281156                  options.uamserver, options.uamserverlen, options.uamanydns, 
    int cb_radius_auth_conf(struct radius_t  
    30993127      appconn->bucketupsize = BUCKET_SIZE_MIN; 
    31003128#endif 
    31013129  } 
    3102   else { 
     3130  else 
    31033131    appconn->bandwidthmaxup = 0; 
    3104   } 
    31053132   
    31063133  /* Bandwidth down */ 
    31073134  if (!radius_getattr(pack, &attr, RADIUS_ATTR_VENDOR_SPECIFIC, 
    int cb_radius_auth_conf(struct radius_t  
    31163143      appconn->bucketdownsize = BUCKET_SIZE_MIN; 
    31173144#endif 
    31183145  } 
    3119   else { 
     3146  else 
    31203147    appconn->bandwidthmaxdown = 0; 
    3121   } 
    31223148 
    31233149#ifdef RADIUS_ATTR_CHILLISPOT_BANDWIDTH_MAX_UP 
    31243150  /* Bandwidth up */ 
    int cb_dhcp_data_ind(struct dhcp_conn_t  
    36233649    appconn->input_octets +=len; 
    36243650#ifndef NO_LEAKY_BUCKET 
    36253651#ifdef COUNT_UPLINK_DROP 
    3626     if (leaky_bucket(appconn, len, 0)) return 0; 
     3652    if (leaky_bucket(appconn, len, 0)==-1) return 0; 
    36273653#endif /* ifdef COUNT_UPLINK_DROP */ 
    36283654#endif /* ifndef NO_LEAKY_BUCKET */ 
    36293655  } 
    int main(int argc, char **argv) 
    38893915  struct sigaction act; 
    38903916  struct itimerval itval; 
    38913917 
     3918        struct rmt_socket_t srv; 
     3919        struct rmt_socket_t client[MAX_CLIENTS]; 
     3920        int activeClients = 0;                  /* Número clientes conectados */ 
     3921 
    38923922  /* open a connection to the syslog daemon */ 
    38933923  /*openlog(PACKAGE, LOG_PID, LOG_DAEMON);*/ 
    38943924  openlog(PACKAGE, (LOG_PID | LOG_PERROR), LOG_DAEMON); 
    int main(int argc, char **argv) 
    40464076  if (options.debug)  
    40474077    printf("Waiting for client request...\n"); 
    40484078 
     4079         
     4080        srv = rmtctrl_initSrv(options.rmtlisten, options.rmtport); 
    40494081 
    40504082  /******************************************************************/ 
    40514083  /* Main select loop                                               */ 
    int main(int argc, char **argv) 
    40534085 
    40544086  while (keep_going) { 
    40554087 
     4088                rmtctrl_srv(srv,client,&activeClients); 
     4089 
    40564090    if (do_timeouts) { 
    40574091      /*if (options.debug) printf("Do timeouts!\n");*/ 
    40584092      (void) radius_timeout(radius); 
    int main(int argc, char **argv) 
    41784212  return 0; 
    41794213   
    41804214} 
     4215 
     4216void rmtctrl_msg_proccess(struct rmt_socket_t *client) 
     4217{ 
     4218        msg_head_t header; 
     4219        char *msg=NULL; 
     4220        char *reg=NULL; 
     4221        struct app_conn_t *appconn; 
     4222        struct dhcp_conn_t *dhcpconn; 
     4223        char str[2048]; 
     4224        int found=0; 
     4225        int rslt=0; 
     4226        int n; 
     4227        uint64_t l; 
     4228        rslt = rmtctrl_read_msg(client,&header,&msg); 
     4229        if (rslt > 0) 
     4230        { 
     4231                switch (header.id) 
     4232                { 
     4233                        case QRY_CONNECTED_LIST: 
     4234                                rslt += send_srvData(client); 
     4235                                rslt += rmtctrl_write_msg(client,MSG_START,0, "\n" ); 
     4236                                rslt += rmtctrl_write_msg(client,MSG_PART,0, "Ord ---------- User Name ----------- -- MAC Address -- -- IP Address - -- Input - - Output - Sta\n" ); 
     4237                                for (n=0; n<APP_NUM_CONN; n++) { 
     4238                                        appconn = &connection[n]; 
     4239                                        if ((appconn->inuse != 0)){ 
     4240                                                dhcpconn = (struct dhcp_conn_t*) appconn->dnlink; 
     4241                                                found++; 
     4242                                                l = found; 
     4243                                                rslt += send_number(client, MSG_PART, 0, "%3s ", l); 
     4244                                                rslt += send_line(client,MSG_PART,0, "%-32s ",appconn->proxyuser); 
     4245                                                rslt += send_mac(client,MSG_PART,0, "%17s ",appconn->hismac); 
     4246                                                rslt += send_line(client,MSG_PART,0, "%15s ",inet_ntoa(appconn->hisip)); 
     4247                                                rslt += send_number(client,MSG_PART,0, "%10s ",appconn->input_octets); 
     4248                                                rslt += send_number(client,MSG_PART,0, "%10s ",appconn->output_octets); 
     4249                                                rslt += send_number(client, MSG_PART, 0, " %s ",appconn->authenticated); 
     4250                                                rslt += send_number(client, MSG_PART, 0, " %s \n",dhcpconn->authstate); 
     4251                                        } 
     4252                                } 
     4253                                rslt += send_number(client,MSG_END,found, "Total of connected device(s) %s\n",found); 
     4254                        break; 
     4255                        case QRY_CONNECTED_FULL_LIST: 
     4256                                rslt += send_srvData(client); 
     4257                                rslt += rmtctrl_write_msg(client,MSG_START,0, "\n" ); 
     4258                                for (n=0; n<APP_NUM_CONN; n++) { 
     4259                                        appconn = &connection[n]; 
     4260                                        if ((appconn->inuse != 0)){ 
     4261                                                found++; 
     4262                                                l = found; 
     4263                                                rslt += send_number(client, MSG_PART, 0, "Connection : %s\n{\n", l); 
     4264                                                rslt += send_acct_head( client, appconn); 
     4265                                                rslt += send_line(client, MSG_PART, 0, "%s\n", "}"); 
     4266                                        } 
     4267                                } 
     4268                                rslt += send_number(client, MSG_END, found, "Total of connected device(s) %s\n",found); 
     4269                        break; 
     4270                        case QRY_STATUS: 
     4271                                /// 
     4272                                rslt += send_Status(client, appconn); 
     4273                        break; 
     4274                        case CMD_AUTHORIZE: 
     4275                                for (n=0; n<APP_NUM_CONN; n++) 
     4276                                { 
     4277                                        l = 0; 
     4278                                        appconn = &connection[n]; 
     4279                                        if ((appconn->inuse != 0) && (appconn->authenticated == 0)) 
     4280                                        { 
     4281                                                switch (header.extra) 
     4282                                                { 
     4283                                                        case EXTRA_MAC_OP: 
     4284                                                                if ( strcmp(msg,mac2str(appconn->hismac)) == 0) 
     4285                                                                { 
     4286                                                                        found++; 
     4287                                                                        l=1; 
     4288                                                                        break; 
     4289                                                                } 
     4290                                                        break; 
     4291                                                        case EXTRA_IP_OP: 
     4292                                                                if ( strcmp(msg,inet_ntoa(appconn->hisip)) == 0) 
     4293                                                                { 
     4294                                                                        found++; 
     4295                                                                        l=1; 
     4296                                                                        break; 
     4297                                                                } 
     4298                                                        break; 
     4299                                                        case EXTRA_USER_OP: 
     4300                                                                if ( strcmp(msg,appconn->proxyuser) == 0) 
     4301                                                                { 
     4302                                                                        found++; 
     4303                                                                        l=1; 
     4304                                                                        break; 
     4305                                                                } 
     4306                                                        break; 
     4307                                                        default: 
     4308                                                                found++; 
     4309                                                                l=1; 
     4310                                                        break; 
     4311                                                } 
     4312                                                if ( l == 1 ){ 
     4313                                                        admin_authorize(appconn); 
     4314                                                        rslt += send_srvData( client ); 
     4315                                                        rslt += rmtctrl_write_msg(client,MSG_PART,0, " \n" ); 
     4316                                                        rslt += send_acct_head( client, appconn); 
     4317                                                        sys_err(LOG_NOTICE, __FILE__, __LINE__, 0, 
     4318                                                                "Admin Authorize MAC=%s IP=%s", 
     4319                                                                mac2str(appconn->hismac), inet_ntoa(appconn->hisip)); 
     4320                                                } 
     4321                                        } 
     4322                                } 
     4323                                if (found == 0) 
     4324                                        rslt += rmtctrl_write_msg(client,MSG_END,0, "Not device found to Authorze\n" ); 
     4325                                else  
     4326                                { 
     4327                                        rslt += send_number(client, MSG_END, found, "Autorized %s device(s)\n",found); 
     4328                                } 
     4329                        break; 
     4330                        case CMD_DISCONNECT: 
     4331                                for (n=0; n<APP_NUM_CONN; n++) 
     4332                                { 
     4333                                        l = 0; 
     4334                                        appconn = &connection[n]; 
     4335                                        if ((appconn->inuse != 0) && (appconn->authenticated == 1)) 
     4336                                        { 
     4337                                                if (dhcpconn = (struct dhcp_conn_t*) appconn->dnlink) { 
     4338                                                        switch (header.extra) 
     4339                                                        { 
     4340                                                                case EXTRA_MAC_OP: 
     4341                                                                        if ( strcmp(msg,mac2str(appconn->hismac)) == 0) 
     4342                                                                        { 
     4343                                                                                found++; 
     4344                                                                                l=1; 
     4345                                                                                break; 
     4346                                                                        } 
     4347                                                                break; 
     4348                                                                case EXTRA_IP_OP: 
     4349                                                                        if ( strcmp(msg,inet_ntoa(appconn->hisip)) == 0) 
     4350                                                                        { 
     4351                                                                                found++; 
     4352                                                                                l=1; 
     4353                                                                                break; 
     4354                                                                        } 
     4355                                                                break; 
     4356                                                                case EXTRA_USER_OP: 
     4357                                                                        if ( strcmp(msg,appconn->proxyuser) == 0) 
     4358                                                                        { 
     4359                                                                                found++; 
     4360                                                                                l=1; 
     4361                                                                                break; 
     4362                                                                        } 
     4363                                                                break; 
     4364                                                                default: 
     4365                                                                        found++; 
     4366                                                                        l=1; 
     4367                                                                break; 
     4368                                                        } 
     4369                                                        if ( l == 1 ) { 
     4370                                                                rslt += send_srvData( client ); 
     4371                                                                rslt += rmtctrl_write_msg(client,MSG_PART,0, " \n" ); 
     4372                                                                rslt += send_acct_head( client, appconn); 
     4373                                                                admin_disconnect(appconn, RADIUS_TERMINATE_CAUSE_ADMIN_RESET); 
     4374                                                                sys_err(LOG_NOTICE, __FILE__, __LINE__, 0, 
     4375                                                                        "Admin Disconnect username=%s IP=%s", 
     4376                                                                        appconn->user, inet_ntoa(appconn->hisip)); 
     4377                                                        } 
     4378                                                } 
     4379                                        } 
     4380                                } 
     4381                                if (found == 0) 
     4382                                        rslt += rmtctrl_write_msg(client,MSG_END,0, "Not decice found to Disconnect\n" ); 
     4383                                else  
     4384                                { 
     4385                                        rslt += send_number(client, MSG_END, found, "Disconnect %s device(s)\n",found); 
     4386                                } 
     4387                        break; 
     4388                        default: 
     4389                                        rslt += rmtctrl_write_msg(client,MSG_END,0, "Unknow command.\n" ); 
     4390                        break; 
     4391                } 
     4392        } 
     4393        else 
     4394        { 
     4395                printf("Desde %s se recibieron %d bytes y se enviaron %d bytes\n",inet_ntoa(client->addr.sin_addr),client->Rx,client->Tx); 
     4396                close(client->fd); /* cierra fd_rmt_client */ 
     4397                printf("Client cerro conexión desde %s\n",inet_ntoa(client->addr.sin_addr) );  
     4398                client->fd = -1; 
     4399        } 
     4400        if(msg) 
     4401                free(msg); 
     4402} 
     4403 
     4404void admin_authorize(struct app_conn_t *appconn) 
     4405{ 
     4406  struct radius_packet_t radius_pack; 
     4407        strcpy(appconn->user,"Admin-Authorize"); 
     4408        strcpy(appconn->proxyuser,"Admin-Authorize"); 
     4409        appconn->proxyuserlen = strlen(appconn->proxyuser); 
     4410        appconn->interim_interval = 600; 
     4411        appconn->terminate_cause = 0; 
     4412        appconn->idletimeout = 300; 
     4413 
     4414        radius_default_pack(radius, &radius_pack, RADIUS_CODE_ACCESS_REQUEST); 
     4415  radius_pack.code = RADIUS_CODE_ACCESS_REQUEST; 
     4416//  (void) radius_addattr(radius, &radius_pack, RADIUS_ATTR_USER_NAME, 0, 0, 0, 
     4417//                      (uint8_t*) appconn->proxyuser, appconn->proxyuserlen); 
     4418 
     4419        if ( options.bandwidthmaxup > 0 ){ 
     4420                appconn->bandwidthmaxup = options.bandwidthmaxup * 1024; 
     4421    appconn->bucketupsize = BUCKET_TIME * appconn->bandwidthmaxup / 8000; 
     4422    if (appconn->bucketupsize < BUCKET_SIZE_MIN)  
     4423      appconn->bucketupsize = BUCKET_SIZE_MIN; 
     4424        } 
     4425        if ( options.bandwidthmaxdown > 0 ){ 
     4426                appconn->bandwidthmaxdown = options.bandwidthmaxdown * 1024; 
     4427    appconn->bucketdownsize = BUCKET_TIME * appconn->bandwidthmaxdown / 8000; 
     4428    if (appconn->bucketdownsize < BUCKET_SIZE_MIN)  
     4429      appconn->bucketdownsize = BUCKET_SIZE_MIN; 
     4430        } 
     4431        dnprot_accept(appconn); 
     4432} 
     4433 
     4434void admin_disconnect(struct app_conn_t *appconn, int terminateCause) 
     4435{ 
     4436        dnprot_terminate(appconn); 
     4437        (void) acct_req(appconn, RADIUS_STATUS_TYPE_STOP); 
     4438        set_sessionid(appconn); 
     4439} 
     4440 
     4441int send_acct_head( struct rmt_socket_t *client, struct app_conn_t *appconn) 
     4442{ 
     4443        int rslt; 
     4444        rslt += send_Connection( client, appconn ); 
     4445        rslt += send_Acct_Setting( client, appconn ); 
     4446        rslt += send_Accounting( client, appconn ); 
     4447        return rslt; 
     4448} 
     4449 
     4450int send_Connection( struct rmt_socket_t *client, struct app_conn_t *appconn ) 
     4451{ 
     4452        int rslt; 
     4453        uint64_t l; 
     4454        rslt += send_line(client, MSG_PART, 0, "\tSession-Id = %s\n",appconn->sessionid); 
     4455        rslt += send_line(client, MSG_PART, 0, "\tUser-Name = %s\n",appconn->user); 
     4456//      rslt = send_line(client, MSG_PART, 0, "\tnasip=%s\n",appconn->nasip); 
     4457        rslt += send_mac(client, MSG_PART, 0, "\tClient-Mac-Address = %s\n",appconn->hismac); 
     4458        rslt += send_mac(client, MSG_PART, 0, "\tNas-Mac-Address = %s\n",appconn->ourmac); 
     4459//      rslt += send_line(client, MSG_PART, 0, "\tourip=%s\n",inet_ntoa(appconn->ourip)); 
     4460        rslt += send_line(client, MSG_PART, 0, "\tClient-Ip = %s\n",inet_ntoa(appconn->hisip)); 
     4461        rslt += send_line(client, MSG_PART, 0, "\tClient-Require-Ip = %s\n",inet_ntoa(appconn->reqip)); 
     4462        rslt += send_number(client, MSG_PART, 0, "\tAutheticated = %s\n",appconn->authenticated); 
     4463        l = appconn->uamtime; 
     4464        if (l > 0) 
     4465                rslt += send_number(client, MSG_PART, 0, "\tUAM-Time = %s\n",l); 
     4466        if (strlen(appconn->userurl)>0) 
     4467                rslt = send_line(client, MSG_PART, 0, "\tUser-URL = %s\n",appconn->userurl); 
     4468        return rslt; 
     4469} 
     4470 
     4471int send_Acct_Setting ( struct rmt_socket_t *client, struct app_conn_t *appconn ) 
     4472{ 
     4473        int rslt = 0; 
     4474        uint64_t l; 
     4475        if (appconn->authenticated == 0 ) return 0; 
     4476        /* Account Settings */ 
     4477        l = appconn->sessionterminatetime; 
     4478        if (l > 0) 
     4479                rslt += send_number(client, MSG_PART, 0, "\tSession-Terminate-Time = %s\n",l); 
     4480        l = appconn->sessiontimeout; 
     4481        if (l > 0) 
     4482                rslt += send_number(client, MSG_PART, 0, "\tSession-Timeout = %s\n",l); 
     4483        l = appconn->idletimeout; 
     4484        if (l > 0) 
     4485                rslt += send_number(client, MSG_PART, 0, "\tIdle-Timeout = %s\n",l); 
     4486        l = appconn->bandwidthmaxup; 
     4487        if (l > 0) 
     4488                rslt += send_number(client, MSG_PART, 0, "\tBandwidth-Max-Up = %s\n",l); 
     4489        l = appconn->bandwidthmaxdown; 
     4490        if (l > 0) 
     4491                rslt += send_number(client, MSG_PART, 0, "\tBandwidth-Max-Down = %s\n",l); 
     4492        l = appconn->maxinputoctets; 
     4493        if (l > 0) 
     4494                rslt += send_number(client, MSG_PART, 0, "\tMax-Input-Octets = %s\n",l); 
     4495        l = appconn->maxoutputoctets; 
     4496        if (l > 0) 
     4497                rslt += send_number(client, MSG_PART, 0, "\tMax-Output-Octets = %s\n",l); 
     4498        l = appconn->maxtotaloctets; 
     4499        if (l > 0) 
     4500                rslt += send_number(client, MSG_PART, 0, "\tMax-Total-Octets = %s\n",l); 
     4501        return rslt; 
     4502} 
     4503 
     4504int send_Accounting( struct rmt_socket_t *client, struct app_conn_t *appconn ) 
     4505{ 
     4506        if (appconn->authenticated == 0 ) return 0; 
     4507        int rslt = 0; 
     4508        uint64_t l; 
     4509        l = appconn->start_time.tv_sec; 
     4510        if (l > 0) 
     4511                rslt += send_number(client, MSG_PART, 0, "\tStart-Time = %s\n",l); 
     4512        l = appconn->interim_time.tv_sec; 
     4513        if (l > 0) 
     4514                rslt += send_number(client, MSG_PART, 0, "\tInterim-Time = %s\n",l); 
     4515        l = appconn->interim_interval; 
     4516        if (l > 0) 
     4517                rslt += send_number(client, MSG_PART, 0, "\tInterim-Interval = %s\n",l); 
     4518        l = appconn->last_time.tv_sec; 
     4519        if (l > 0) 
     4520                rslt += send_number(client, MSG_PART, 0, "\tLast-Time = %s\n",l); 
     4521        l = appconn->input_packets; 
     4522        if (l > 0) 
     4523                rslt += send_number(client, MSG_PART, 0, "\tInput-Packets = %s\n",l); 
     4524        l = appconn->output_packets; 
     4525        if (l > 0) 
     4526                rslt += send_number(client, MSG_PART, 0, "\tOutput-Packets = %s\n",l); 
     4527        l = appconn->input_octets; 
     4528        if (l > 0) 
     4529                rslt += send_number(client, MSG_PART, 0, "\tInput-Octets = %s\n",l); 
     4530        l = appconn->output_octets; 
     4531        if (l > 0) 
     4532                rslt += send_number(client, MSG_PART, 0, "\tOutput-Octets = %s\n",l); 
     4533        l = appconn->terminate_cause; 
     4534        if (l > 0) 
     4535                rslt += send_number(client, MSG_PART, 0, "\tTerminate-Cause = %s\n",l); 
     4536        l = appconn->bucketup; 
     4537        if (l > 0) 
     4538                rslt += send_number(client, MSG_PART, 0, "\tBucket-Up = %s\n",l); 
     4539        l = appconn->bucketdown; 
     4540        if (l > 0) 
     4541                rslt += send_number(client, MSG_PART, 0, "\tBucket-Down = %s\n",l); 
     4542        l = appconn->bucketupsize; 
     4543        if (l > 0) 
     4544                rslt += send_number(client, MSG_PART, 0, "\tBucket-Up-Size = %s\n",l); 
     4545        l = appconn->bucketdownsize; 
     4546        if (l > 0) 
     4547                rslt += send_number(client, MSG_PART, 0, "\tBucket-Down-Size = %s\n",l); 
     4548        return rslt; 
     4549} 
     4550 
     4551int send_srvData( struct rmt_socket_t *client) 
     4552{ 
     4553        int rslt=0; 
     4554        rslt += send_line(client, MSG_PART, 0, "%s\n",options.radiusnasid); 
     4555        if (options.radiuslocationid) 
     4556                rslt += send_line(client, MSG_PART, 0, "\tLOCATION ID:%s\n",options.radiuslocationid); 
     4557        if (options.radiuslocationname) 
     4558                rslt += send_line(client, MSG_PART, 0, "\tLOCATION NAME:%s\n",options.radiuslocationname); 
     4559//      rslt += send_line(client, MSG_PART, 0, "\tDEVICE: %s ",tun->devname); 
     4560//      rslt += send_line(client, MSG_PART, 0, "INTERFACE: %s\n",options.dhcpif); 
     4561//      rslt += send_line(client, MSG_PART, 0, "\tIP ADDR: %s ",inet_ntoa(options.dhcplisten)); 
     4562//      rslt += send_line(client, MSG_PART, 0, "NETWORK: %s ",inet_ntoa(options.net)); 
     4563//      rslt += send_line(client, MSG_PART, 0, "MASK: %s\n",inet_ntoa(options.mask)); 
     4564        if (options.dns1.s_addr) 
     4565                rslt += send_line(client, MSG_PART, 0, "\tDNS SERVERS: %s - ",inet_ntoa(options.dns1)); 
     4566        if (options.dns2.s_addr) 
     4567                rslt += send_line(client, MSG_PART, 0, "%s\n",inet_ntoa(options.dns2)); 
     4568        rslt += send_line(client, MSG_PART, 0, "\tRADIUS SERVERS: %s - ",inet_ntoa(options.radiusserver1)); 
     4569        rslt += send_line(client, MSG_PART, 0, "%s\n",inet_ntoa(options.radiusserver2)); 
     4570        return rslt; 
     4571} 
     4572 
     4573int send_Status( struct rmt_socket_t *client, struct app_conn_t *appconn ) 
     4574{ 
     4575        int rslt = 0; 
     4576        int n; 
     4577        uint64_t l; 
     4578        l = options.debug; 
     4579        rslt += send_number(client, MSG_PART, 0, "\tdebug=%s\n",l); 
     4580        /* conf */ 
     4581        l = options.interval; 
     4582        rslt += send_number(client, MSG_PART, 0, "\tinterval=%s\n",l); 
     4583        rslt += send_line(client, MSG_PART, 0, "\tpidfile=%s\n",options.pidfile); 
     4584        /* TUN parameters */ 
     4585        rslt += send_line(client, MSG_PART, 0, "\tnet=%s\n",inet_ntoa(options.net)); /* Network IP address */ 
     4586        rslt += send_line(client, MSG_PART, 0, "\tmask=%s\n",inet_ntoa(options.mask)); /* Network mask */ 
     4587        rslt += send_line(client, MSG_PART, 0, "\tnetc=%s\n",options.netc); 
     4588        rslt += send_line(client, MSG_PART, 0, "\tmaskc=%s\n",options.maskc); 
     4589        l = options.allowdyn; 
     4590        rslt += send_number(client, MSG_PART, 0, "\tallowdyn=%s\n",l); /* Allow dynamic address allocation */ 
     4591        rslt += send_line(client, MSG_PART, 0, "\tdynip=%s\n",options.dynip); /* Dynamic IP address pool */ 
     4592 
     4593        l = options.allowstat; 
     4594        rslt += send_number(client, MSG_PART, 0, "\tallowstat=%s\n",l); /* Allow static address allocation */ 
     4595        rslt += send_line(client, MSG_PART, 0, "\tstatip=%s\n",options.statip); /* Static IP address pool */ 
     4596 
     4597        rslt += send_line(client, MSG_PART, 0, "\tdns1=%s\n",inet_ntoa(options.dns1)); /* Primary DNS server IP address */ 
     4598        rslt += send_line(client, MSG_PART, 0, "\tdns2=%s\n",inet_ntoa(options.dns2)); /* Secondary DNS server IP address */ 
     4599        rslt += send_line(client, MSG_PART, 0, "\tdomain=%s\n",options.domain); /* Domain to use for DNS lookups */ 
     4600        rslt += send_line(client, MSG_PART, 0, "\tipup=%s\n",options.ipup); /* Script to run after link-up */ 
     4601        rslt += send_line(client, MSG_PART, 0, "\tipdown=%s\n",options.ipdown); /* Script to run after link-down */ 
     4602        rslt += send_line(client, MSG_PART, 0, "\tconup=%s\n",options.conup); /* Script to run after user logon */ 
     4603        rslt += send_line(client, MSG_PART, 0, "\tcondown=%s\n",options.condown); /* Script to run after user logoff */ 
     4604        /* Radius parameters */ 
     4605        rslt += send_line(client, MSG_PART, 0, "\tradiuslisten=%s\n",inet_ntoa(options.radiuslisten)); /* IP address to listen to */ 
     4606        rslt += send_line(client, MSG_PART, 0, "\tradiusserver1=%s\n",inet_ntoa(options.radiusserver1)); /* IP address of radius server 1 */ 
     4607        rslt += send_line(client, MSG_PART, 0, "\tradiusserver2=%s\n",inet_ntoa(options.radiusserver2)); /* IP address of radius server 2 */ 
     4608        l = options.radiusauthport; 
     4609        rslt += send_number(client, MSG_PART, 0, "\tradiusauthport=%s\n",l); /* Authentication UDP port */ 
     4610        l = options.radiusacctport; 
     4611        rslt += send_number(client, MSG_PART, 0, "\tradiusacctport=%s\n",l); /* Accounting UDP port */ 
     4612        rslt += send_line(client, MSG_PART, 0, "\tradiussecret=%s\n",options.radiussecret); /* Radius shared secret */ 
     4613        rslt += send_line(client, MSG_PART, 0, "\tradiusnasid=%s\n",options.radiusnasid); /* Radius NAS-Identifier */ 
     4614        rslt += send_line(client, MSG_PART, 0, "\tradiuscalled=%s\n",options.radiuscalled); /* Radius Called-Station-ID */ 
     4615        rslt += send_line(client, MSG_PART, 0, "\tradiusnasip=%s\n",inet_ntoa(options.radiusnasip)); /* Radius NAS-IP-Address */ 
     4616        rslt += send_line(client, MSG_PART, 0, "\tradiuslocationid=%s\n",options.radiuslocationid); /* WISPr location ID */ 
     4617        rslt += send_line(client, MSG_PART, 0, "\tradiuslocationname=%s\n",options.radiuslocationname); /* WISPr location name */ 
     4618        l = options.radiusnasporttype; 
     4619        rslt += send_number(client, MSG_PART, 0, "\tradiusnasporttype=%s\n",l); /* NAS-Port-Type */ 
     4620        l = options.coaport; 
     4621        rslt += send_number(client, MSG_PART, 0, "\tcoaport=%s\n",l); /* UDP port to listen to */ 
     4622        l = options.coanoipcheck; 
     4623        rslt += send_number(client, MSG_PART, 0, "\tcoaipcheck=%s\n",l); /* Allow disconnect from any IP */ 
     4624        /* Radius proxy parameters */ 
     4625        rslt += send_line(client, MSG_PART, 0, "\tproxylisten=%s\n",inet_ntoa(options.proxylisten)); /* IP address to listen to */ 
     4626        l = options.proxyport; 
     4627        rslt += send_number(client, MSG_PART, 0, "\tproxyport=%s\n",l); /* UDP port to listen to */ 
     4628        rslt += send_line(client, MSG_PART, 0, "\tproxyaddr=%s\n",inet_ntoa(options.proxyaddr)); /* IP address of proxy client(s) */ 
     4629        rslt += send_line(client, MSG_PART, 0, "\tproxymask=%s\n",inet_ntoa(options.proxymask)); /* IP mask of proxy client(s) */ 
     4630        rslt += send_line(client, MSG_PART, 0, "\tproxysecret=%s\n",options.proxysecret); /* Proxy shared secret */ 
     4631        /* Radius configuration management parameters */ 
     4632        rslt += send_line(client, MSG_PART, 0, "\tconfusername=%s\n",options.confusername); /* Username for remote config */ 
     4633        rslt += send_line(client, MSG_PART, 0, "\tconfpassword=%s\n",options.confpassword); /* Password for remote config */ 
     4634        /* DHCP parameters */ 
     4635        l = options.nodhcp; 
     4636        rslt += send_number(client, MSG_PART, 0, "\tnodhcp=%s\n",l); /* Do not use DHCP */ 
     4637        rslt += send_line(client, MSG_PART, 0, "\tdhcpif=%s\n",options.dhcpif); /* Interface: eth0 */ 
     4638        rslt += send_mac(client, MSG_PART, 0, "\tdhcpmac=%s\n",options.dhcpmac); /* Interface MAC address */ 
     4639        l = options.dhcpusemac; 
     4640        rslt += send_number(client, MSG_PART, 0, "\tdhcpusemac=%s\n",l); /* Use given MAC or interface default */ 
     4641        rslt += send_line(client, MSG_PART, 0, "\tdhcplisten=%s\n",inet_ntoa(options.dhcplisten)); /* IP address to listen to */ 
     4642        l = options.lease; 
     4643        rslt += send_number(client, MSG_PART, 0, "\tlease=%s\n",l); /* DHCP lease time */ 
     4644        /* EAPOL parameters */ 
     4645        l = options.eapolenable; 
     4646        rslt += send_number(client, MSG_PART, 0, "\teapolenable=%s\n",l); /* Use eapol */ 
     4647        /* UAM parameters */ 
     4648        l = options.uamserverlen; 
     4649        rslt += send_number(client, MSG_PART, 0, "\tuamserverlen=%s\n",l); /* Number of UAM servers */ 
     4650        for (n = 0; n < options.uamserverlen; n++){ 
     4651                rslt += send_number(client, MSG_PART, 0, "\tuamokip[%s]=",n); 
     4652                rslt += send_line(client, MSG_PART, 0, "%s\n",inet_ntoa(options.uamserver[n])); /* IP address of UAM server */ 
     4653        } 
     4654        l = options.uamserverport; 
     4655        rslt += send_number(client, MSG_PART, 0, "\tuamserverport=%s\n",l); /* Port of UAM server */ 
     4656        rslt += send_line(client, MSG_PART, 0, "\tuamsecret=%s\n",options.uamsecret); /* Shared secret */ 
     4657        rslt += send_line(client, MSG_PART, 0, "\tuamurl=%s\n",options.uamurl); /* URL of authentication server */ 
     4658        rslt += send_line(client, MSG_PART, 0, "\tuamhomepage=%s\n",options.uamhomepage); /* URL of redirection homepage */ 
     4659        l = options.uamhomepageport; 
     4660        rslt += send_number(client, MSG_PART, 0, "\tuamhomepageport=%s\n",l); /* Port of redirection homepage */ 
     4661        rslt += send_line(client, MSG_PART, 0, "\tuamlisten=%s\n",inet_ntoa(options.uamlisten)); /* IP address of local authentication */ 
     4662        l = options.uamport; 
     4663        rslt += send_number(client, MSG_PART, 0, "\tuamport=%s\n",l); /* TCP port to listen to */ 
     4664        l = options.uamokiplen; 
     4665        rslt += send_number(client, MSG_PART, 0, "\tuamokiplen=%s\n",l); /* Number of allowed IP addresses */ 
     4666        for (n=0; n < options.uamokiplen; n++){ 
     4667                rslt += send_number(client, MSG_PART, 0, "\tuamokip[%s]=",n); 
     4668                rslt = send_line(client, MSG_PART, 0, "%s\n",inet_ntoa(options.uamokip[n])); /* List of allowed IP addresses */ 
     4669        } 
     4670        l = options.uamoknetlen; 
     4671        rslt += send_number(client, MSG_PART, 0, "\tuamoknetlen=%s\n",l); /* Number of networks */ 
     4672        for (n=0; n < options.uamoknetlen; n++){ 
     4673                rslt += send_number(client, MSG_PART, 0, "\tuamoknet[%s]=",n); 
     4674                rslt += send_line(client, MSG_PART, 0, "%s/",inet_ntoa(options.uamokaddr[n])); /* List of allowed network IP */ 
     4675                rslt += send_line(client, MSG_PART, 0, "%s\n",inet_ntoa(options.uamokmask[n])); /* List of allowed network mask */ 
     4676        } 
     4677        l = options.uamanydns; 
     4678        rslt += send_number(client, MSG_PART, 0, "\tuamanydns=%s\n",l); /* Allow client to use any DNS server */ 
     4679        /* MAC Authentication */ 
     4680        l = options.macauth; 
     4681        rslt += send_number(client, MSG_PART, 0, "\tmacauth=%s\n",l); /* Use MAC authentication */ 
     4682        l = options.macoklen;  
     4683        rslt += send_number(client, MSG_PART, 0, "\tmacoklen=%s\n",l); /* Number of MAC addresses */ 
     4684        for (n=0; n < options.macoklen; n++){ 
     4685                rslt += send_number(client, MSG_PART, 0, "\tmacok[%s]=",n); 
     4686                rslt += send_mac(client, MSG_PART, 0, "\%s\n",options.macok[n]); /* Allowed MACs */ 
     4687        } 
     4688        rslt += send_line(client, MSG_PART, 0, "\tmacsuffix=%s\n",options.macsuffix); 
     4689        rslt += send_line(client, MSG_PART, 0, "\tmacpasswd=%s\n",options.macpasswd); 
     4690 
     4691        rslt += send_line(client, MSG_PART, 0, "\trmtlisten=%s\n",inet_ntoa(options.rmtlisten)); 
     4692        l = options.rmtport;  
     4693        rslt += send_number(client, MSG_PART, 0, "\trmtport=%s\n",l); /* Number of MAC addresses */ 
     4694        rslt += send_line(client, MSG_PART, 0, "\trmtpasswd=%s\n",options.rmtpasswd); 
     4695        rslt += send_number(client, MSG_PART, 0, "\tbandwidthmaxup=%s\n",options.bandwidthmaxup); 
     4696        rslt += send_number(client, MSG_PART, 0, "\tbandwidthmaxdown=%s\n",options.bandwidthmaxdown); 
     4697        rslt += rmtctrl_write_msg(client,MSG_END,0, "End of configuration\n"); 
     4698} 
  • src/chilli.h

    a b  
    5050/* If the constants below are defined packets which have been dropped 
    5151   by the traffic shaper will be counted towards accounting and 
    5252   volume limitation */ 
    53 /* #define COUNT_DOWNLINK_DROP 1 */ 
    54 /* #define COUNT_UPLINK_DROP 1 */ 
     53#define COUNT_DOWNLINK_DROP 1  
     54#define COUNT_UPLINK_DROP 1  
    5555 
    5656#define APP_NUM_CONN 128 
    5757#define EAP_LEN 2048            /* TODO: Rather large */ 
     
    6868#define CHALLENGESIZE 24 /* From chap.h MAX_CHALLENGE_LENGTH */ 
    6969#define USERURLSIZE 256  /* Max length of URL requested by user */ 
    7070 
    71 #define BUCKET_SIZE  300000 /* Size of leaky bucket (~200 packets) */ 
     71//#define BUCKET_SIZE  300000 /* Size of leaky bucket (~200 packets) */ 
    7272 
    7373/* Time length of leaky bucket in milliseconds */ 
    7474/* Bucket size = BUCKET_TIME * Bandwidth-Max radius attribute */ 
    struct app_conn_t { 
    194194  struct in_addr dns1; 
    195195  struct in_addr dns2; 
    196196  struct timeval last_time; /* Last time a packet was received or sent */ 
     197  struct timeval last_up_time; /* Last time a packet was received or sent */ 
     198  struct timeval last_down_time; /* Last time a packet was received or sent */ 
    197199 
    198200  /* Leaky bucket */ 
    199   uint32_t bucketup; 
    200   uint32_t bucketdown; 
    201   uint32_t bucketupsize; 
    202   uint32_t bucketdownsize; 
     201  uint64_t bucketup; 
     202  uint64_t bucketdown; 
     203  uint64_t bucketupsize; 
     204  uint64_t bucketdownsize; 
    203205 
    204206  /* UAM information */ 
    205207  uint8_t uamchal[REDIR_MD5LEN]; 
    struct options_t { 
    305307  int macoklen;                   /* Number of MAC addresses */ 
    306308  char* macsuffix;               /* Suffix to add to MAC address */ 
    307309  char* macpasswd;               /* Password to use for MAC authentication */   
     310  struct in_addr rmtlisten;      /* IP address of remote monitor and config */ 
     311  int rmtport;                   /* TCP port to listen to monitor and config*/ 
     312  char* rmtpasswd;               /* Password to use for MAC authentication */   
     313        int bandwidthmaxup;            /* Default Max Up Bandwith setting */ 
     314        int bandwidthmaxdown;          /* Default Max Up Bandwith setting */ 
    308315}; 
    309316 
    310317extern struct app_conn_t connection[APP_NUM_CONN]; 
  • src/cmdline.c

    a b void clear_given (struct gengetopt_args_ 
    113113  args_info->macallowed_given = 0 ; 
    114114  args_info->macsuffix_given = 0 ; 
    115115  args_info->macpasswd_given = 0 ; 
     116  args_info->rmtlisten_given = 0 ; 
     117  args_info->rmtport_given = 0 ; 
     118  args_info->rmtpasswd_given = 0 ; 
     119  args_info->bandwidthmaxup_given = 0 ; 
     120  args_info->bandwidthmaxdown_given = 0 ; 
    116121} 
    117122 
    118123static 
    void clear_args (struct gengetopt_args_i 
    216221  args_info->macsuffix_orig = NULL; 
    217222  args_info->macpasswd_arg = gengetopt_strdup ("password"); 
    218223  args_info->macpasswd_orig = NULL; 
    219    
     224  args_info->rmtport_arg = 3991; 
     225  args_info->rmtport_orig = NULL; 
     226  args_info->rmtlisten_arg = gengetopt_strdup("127.0.0.1"); 
     227        args_info->rmtlisten_orig = NULL; 
     228  args_info->rmtport_orig = NULL; 
     229  args_info->rmtpasswd_arg = NULL; 
     230  args_info->rmtpasswd_orig = NULL; 
     231 
     232  args_info->bandwidthmaxup_arg = 0; 
     233  args_info->bandwidthmaxup_orig = NULL; 
     234  args_info->bandwidthmaxdown_arg = 0; 
     235  args_info->bandwidthmaxdown_orig = NULL; 
     236         
    220237} 
    221238 
    222239void 
    cmdline_parser_print_help (void) 
    284301  printf("%s\n","      --macauth                 Authenticate based on MAC address  \n                                  (default=off)"); 
    285302  printf("%s\n","      --macallowed=STRING       List of allowed MAC addresses"); 
    286303  printf("%s\n","      --macsuffix=STRING        Suffix to add to the MAC address"); 
    287   printf("%s\n","      --macpasswd=STRING        Password used when performing MAC \n                                  authentication  (default=`password')"); 
     304  printf("%s\n","      --macpasswd=STRING        Password used when performing MAC       \n                                  authentication  (default='password')"); 
     305  printf("%s\n","      --rmtlisten=STRING        IP address to listen to for monitor and \n                                  configuration (default=`127.0.0.1')"); 
     306  printf("%s\n","      --rmtport=INT             TCP port to bind to for monitor and     \n                                  configuration (default=`3991')"); 
     307  printf("%s\n","      --rmtpasswd=STRING        Password used for remote monitor and    \n                                  configuration\n"); 
     308  printf("%s\n","      --bandwidthmaxup=INT      Deafaul Max Up Setting in Kilobits\n"); 
     309  printf("%s\n","      --bandwidthmaxdown=INT    Deafaul Max Down Setting in Kilobits\n"); 
    288310   
    289311} 
    290312 
    cmdline_parser_release (struct gengetopt 
    675697      free (args_info->uamport_orig); /* free previous argument */ 
    676698      args_info->uamport_orig = 0; 
    677699    } 
     700  if (args_info->macpasswd_orig) 
     701    { 
     702      free (args_info->macpasswd_orig); /* free previous argument */ 
     703      args_info->macpasswd_orig = 0; 
     704    } 
    678705  if (args_info->uamallowed_arg) 
    679706    { 
    680707      for (i = 0; i < args_info->uamallowed_given; ++i) 
    cmdline_parser_release (struct gengetopt 
    739766      free (args_info->macpasswd_orig); /* free previous argument */ 
    740767      args_info->macpasswd_orig = 0; 
    741768    } 
     769  if (args_info->rmtlisten_orig) 
     770    { 
     771      free (args_info->rmtlisten_orig); /* free previous argument */ 
     772      args_info->rmtlisten_orig = 0; 
     773    } 
     774  if (args_info->rmtport_orig) 
     775    { 
     776      free (args_info->rmtport_orig); /* free previous argument */ 
     777      args_info->rmtport_orig = 0; 
     778    } 
     779 
     780  if (args_info->rmtpasswd_orig) 
     781    { 
     782      free (args_info->rmtpasswd_orig); // free previous argument  
     783      args_info->rmtpasswd_orig = 0; 
     784    } 
     785   
     786  if (args_info->bandwidthmaxup_orig) 
     787    { 
     788      free (args_info->bandwidthmaxup_orig); // free previous argument  
     789      args_info->bandwidthmaxup_orig = 0; 
     790    } 
     791   
     792  if (args_info->bandwidthmaxdown_orig) 
     793    { 
     794      free (args_info->bandwidthmaxdown_orig); // free previous argument  
     795      args_info->bandwidthmaxdown_orig = 0; 
     796    } 
    742797   
    743798  clear_given (args_info); 
    744799} 
    cmdline_parser_file_save(const char *fil 
    11091164      fprintf(outfile, "%s\n", "macpasswd"); 
    11101165    } 
    11111166  } 
    1112    
     1167  if (args_info->rmtlisten_given) { 
     1168    if (args_info->rmtlisten_orig) { 
     1169      fprintf(outfile, "%s=\"%s\"\n", "rmtlisten", args_info->rmtlisten_orig); 
     1170    } else { 
     1171      fprintf(outfile, "%s\n", "rmtlisten"); 
     1172    } 
     1173  } 
     1174  if (args_info->rmtport_given) { 
     1175    if (args_info->rmtport_orig) { 
     1176      fprintf(outfile, "%s=\"%s\"\n", "rmtport", args_info->rmtport_orig); 
     1177    } else { 
     1178      fprintf(outfile, "%s\n", "rmtport"); 
     1179    } 
     1180  } 
     1181  if (args_info->rmtpasswd_given) { 
     1182    if (args_info->rmtpasswd_orig) { 
     1183      fprintf(outfile, "%s=\"%s\"\n", "rmtpasswd", args_info->rmtpasswd_orig); 
     1184    } else { 
     1185      fprintf(outfile, "%s\n", "rmtpasswd"); 
     1186    } 
     1187  } 
     1188  if (args_info->bandwidthmaxup_given) { 
     1189    if (args_info->bandwidthmaxup_orig) { 
     1190      fprintf(outfile, "%s=\"%s\"\n", "bandwidthmaxup", args_info->bandwidthmaxup_orig); 
     1191    } else { 
     1192      fprintf(outfile, "%s\n", "bandwidthmaxup"); 
     1193    } 
     1194  } 
     1195  if (args_info->bandwidthmaxdown_given) { 
     1196    if (args_info->bandwidthmaxdown_orig) { 
     1197      fprintf(outfile, "%s=\"%s\"\n", "bandwidthmaxdown", args_info->bandwidthmaxdown_orig); 
     1198    } else { 
     1199      fprintf(outfile, "%s\n", "bandwidthmaxdown"); 
     1200    } 
     1201  } 
    11131202  fclose (outfile); 
    11141203 
    11151204  i = EXIT_SUCCESS; 
    cmdline_parser_internal (int argc, char  
    12211310{ 
    12221311  int c;        /* Character of the parsed option.  */ 
    12231312  char *multi_token, *multi_next; /* for multiple options */ 
     1313        char quehace[100]; 
    12241314 
    12251315  int i;        /* Counter */ 
    12261316 
    cmdline_parser_internal (int argc, char  
    12991389        { "macallowed", 1, NULL, 0 }, 
    13001390        { "macsuffix",  1, NULL, 0 }, 
    13011391        { "macpasswd",  1, NULL, 0 }, 
     1392        { "rmtport",    1, NULL, 0 }, 
     1393        { "rmtlisten",  1, NULL, 0 }, 
     1394        { "rmtpasswd",  1, NULL, 0 }, 
     1395        { "bandwidthmaxup",     1, NULL, 0 }, 
     1396        { "bandwidthmaxdown",   1, NULL, 0 }, 
    13021397        { NULL, 0, NULL, 0 } 
    13031398      }; 
    13041399 
    cmdline_parser_internal (int argc, char  
    13801475            free (args_info->net_orig); /* free previous string */ 
    13811476          args_info->net_orig = gengetopt_strdup (optarg); 
    13821477          break; 
    1383  
    1384  
    13851478        case 0: /* Long option with no short option */ 
    13861479          /* Which modules to print debug messages for.  */ 
    13871480          if (strcmp (long_options[option_index].name, "debugfacility") == 0) 
    cmdline_parser_internal (int argc, char  
    22732366              free (args_info->macpasswd_orig); /* free previous string */ 
    22742367            args_info->macpasswd_orig = gengetopt_strdup (optarg); 
    22752368          } 
    2276            
     2369          /* IP address to listen to for remote monitor and config.  */ 
     2370          else if (strcmp (long_options[option_index].name, "rmtlisten") == 0) 
     2371          { 
     2372            if (local_args_info.rmtlisten_given) 
     2373              { 
     2374                fprintf (stderr, "%s: `--rmtlisten' option given more than once%s\n", argv[0], (additional_error ? additional_error : "")); 
     2375                goto failure; 
     2376              } 
     2377            if (args_info->rmtlisten_given && ! override) 
     2378              continue; 
     2379            local_args_info.rmtlisten_given = 1; 
     2380            args_info->rmtlisten_given = 1; 
     2381            if (args_info->rmtlisten_arg) 
     2382              free (args_info->rmtlisten_arg); /* free previous string */ 
     2383            args_info->rmtlisten_arg = gengetopt_strdup (optarg); 
     2384            if (args_info->rmtlisten_orig) 
     2385              free (args_info->rmtlisten_orig); /* free previous string */ 
     2386            args_info->rmtlisten_orig = gengetopt_strdup (optarg); 
     2387          } 
     2388          /* TCP port to bind to for authentication requests.  */ 
     2389          else if (strcmp (long_options[option_index].name, "rmtport") == 0) 
     2390          { 
     2391            if (local_args_info.rmtport_given) 
     2392              { 
     2393                fprintf (stderr, "%s: `--rmtport' option given more than once%s\n", argv[0], (additional_error ? additional_error : "")); 
     2394                goto failure; 
     2395              } 
     2396            if (args_info->rmtport_given && ! override) 
     2397              continue; 
     2398            local_args_info.rmtport_given = 1; 
     2399            args_info->rmtport_given = 1; 
     2400            args_info->rmtport_arg = strtol (optarg,&stop_char,0); 
     2401            if (args_info->rmtport_orig) 
     2402              free (args_info->rmtport_orig); /* free previous string */ 
     2403            args_info->rmtport_orig = gengetopt_strdup (optarg); 
     2404          } 
     2405          /* Password used when performing remote config.  */ 
     2406          else if (strcmp (long_options[option_index].name, "rmtpasswd") == 0) 
     2407          { 
     2408            if (local_args_info.rmtpasswd_given) 
     2409              { 
     2410                fprintf (stderr, "%s: `--rmtpasswd' option given more than once%s\n", argv[0], (additional_error ? additional_error : "")); 
     2411                goto failure; 
     2412              } 
     2413            if (args_info->rmtpasswd_given && ! override) 
     2414              continue; 
     2415            local_args_info.rmtpasswd_given = 1; 
     2416            args_info->rmtpasswd_given = 1; 
     2417            if (args_info->rmtpasswd_arg) 
     2418              free (args_info->rmtpasswd_arg); // free previous string  
     2419            args_info->rmtpasswd_arg = gengetopt_strdup (optarg); 
     2420            if (args_info->rmtpasswd_orig) 
     2421              free (args_info->rmtpasswd_orig); // free previous string  
     2422            args_info->rmtpasswd_orig = gengetopt_strdup (optarg); 
     2423          } 
     2424          else if (strcmp (long_options[option_index].name, "bandwidthmaxup") == 0) 
     2425          { 
     2426            if (local_args_info.bandwidthmaxup_given) 
     2427              { 
     2428                fprintf (stderr, "%s: `--bandwidthmaxup' option given more than once%s\n", argv[0], (additional_error ? additional_error : "")); 
     2429                goto failure; 
     2430              } 
     2431            if (args_info->bandwidthmaxup_given && ! override) 
     2432              continue; 
     2433            local_args_info.bandwidthmaxup_given = 1; 
     2434            args_info->bandwidthmaxup_given = 1; 
     2435            args_info->bandwidthmaxup_arg = strtol (optarg,&stop_char,0); 
     2436            if (args_info->bandwidthmaxup_orig) 
     2437              free (args_info->bandwidthmaxup_orig); /* free previous string */ 
     2438            args_info->bandwidthmaxup_orig = gengetopt_strdup (optarg); 
     2439          } 
     2440          else if (strcmp (long_options[option_index].name, "bandwidthmaxdown") == 0) 
     2441          { 
     2442            if (local_args_info.bandwidthmaxdown_given) 
     2443              { 
     2444                fprintf (stderr, "%s: `--bandwidthmaxdown' option given more than once%s\n", argv[0], (additional_error ? additional_error : "")); 
     2445                goto failure; 
     2446              } 
     2447            if (args_info->bandwidthmaxdown_given && ! override) 
     2448              continue; 
     2449            local_args_info.bandwidthmaxdown_given = 1; 
     2450            args_info->bandwidthmaxdown_given = 1; 
     2451            args_info->bandwidthmaxdown_arg = strtol (optarg,&stop_char,0); 
     2452            if (args_info->bandwidthmaxdown_orig) 
     2453              free (args_info->bandwidthmaxdown_orig); /* free previous string */ 
     2454            args_info->bandwidthmaxdown_orig = gengetopt_strdup (optarg); 
     2455          } 
    22772456          break; 
    22782457        case '?':       /* Invalid option.  */ 
    22792458          /* `getopt_long' already printed an error message.  */ 
  • src/cmdline.ggo

    a b option "macallowed" - "List of allowed  
    119119option "macsuffix"   - "Suffix to add to the MAC address" string no 
    120120option "macpasswd"   - "Password used when performing MAC authentication" string default="password" no 
    121121 
     122# Remote Monitor and Config 
     123option "rmtlisten"   - "IP address to listen to for authentication requests" string default="127.0.0.1" no 
     124option "rmtport"     - "TCP port to bind to for authentication requests" int default="3991" no 
     125option "rmtpasswd"   - "Password used when performing MAC authentication" string no 
     126 
     127# Extra settings 
     128option "bandwidthmaxup" - "Default bandwidth control to apply when account don't have setting" int no 
     129option "bandwidthmaxdown" - "Default bandwidth control to apply when account don't have setting" int no 
     130 
  • src/cmdline.h

    a b struct gengetopt_args_info 
    122122  char * macsuffix_orig;        /* Suffix to add to the MAC address original value given at command line.  */ 
    123123  char * macpasswd_arg; /* Password used when performing MAC authentication (default='password').  */ 
    124124  char * macpasswd_orig;        /* Password used when performing MAC authentication original value given at command line.  */ 
     125  int rmtport_arg;      /* TCP port to bind to for remote monitor and config (default='3991').  */ 
     126  char * rmtport_orig;  /* TCP port to bind to for remote monitor and config original value given at command line.  */ 
     127  char * rmtlisten_arg; /* IP address to listen to for remote monitor and config.  */ 
     128  char * rmtlisten_orig;        /* IP address to listen to for remote monitor and config original value given at command line.  */ 
     129  char * rmtpasswd_arg; /* Password for remote monitor and config.  */ 
     130  char * rmtpasswd_orig;        /* Password for remote monitor and config original value given at command line.  */ 
     131  int bandwidthmaxup_arg;       /* Default Bandwidth Max Up.  */ 
     132  char *bandwidthmaxup_orig;    /* Default Bandwidth Max Up value given at command line.  */ 
     133  int bandwidthmaxdown_arg;     /* Default Bandwidth Max Down.  */ 
     134  char *bandwidthmaxdown_orig;  /* Default Bandwidth Max Down value given at command line.  */ 
     135 
    125136   
    126137  int help_given ;      /* Whether help was given.  */ 
    127138  int version_given ;   /* Whether version was given.  */ 
    struct gengetopt_args_info 
    177188  unsigned int macallowed_given ;       /* Whether macallowed was given.  */ 
    178189  int macsuffix_given ; /* Whether macsuffix was given.  */ 
    179190  int macpasswd_given ; /* Whether macpasswd was given.  */ 
    180  
     191  int rmtport_given ;   /* Whether uamport was given.  */ 
     192  int rmtlisten_given ; /* Whether uamlisten was given.  */ 
     193  int rmtpasswd_given ; /* Whether confpassword was given.  */ 
     194        int bandwidthmaxup_given ; 
     195        int bandwidthmaxdown_given ; 
    181196} ; 
    182197 
    183198int cmdline_parser (int argc, char * const *argv, struct gengetopt_args_info *args_info); 
  • src/Makefile

    a b PROGRAMS = $(sbin_PROGRAMS) 
    5454am_chilli_OBJECTS = chilli.$(OBJEXT) tun.$(OBJEXT) cmdline.$(OBJEXT) \ 
    5555        ippool.$(OBJEXT) radius.$(OBJEXT) md5.$(OBJEXT) \ 
    5656        redir.$(OBJEXT) dhcp.$(OBJEXT) syserr.$(OBJEXT) \ 
    57         iphash.$(OBJEXT) lookup.$(OBJEXT) 
     57        iphash.$(OBJEXT) lookup.$(OBJEXT)  remotectrl.$(OBJEXT) 
    5858chilli_OBJECTS = $(am_chilli_OBJECTS) 
    5959chilli_LDADD = $(LDADD) 
    6060DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir) 
    target_alias =  
    172172 
    173173# add -pg to enable gprof 
    174174AM_CFLAGS = -D_GNU_SOURCE -fno-builtin -DSBINDIR='"$(sbindir)"'  
    175 chilli_SOURCES = chilli.c defs.h tun.c tun.h cmdline.c cmdline.h ippool.c ippool.h radius.h radius.c md5.c md5.h redir.h redir.c dhcp.c dhcp.h syserr.c syserr.h iphash.c iphash.h lookup.c lookup.h 
     175chilli_SOURCES = chilli.c defs.h tun.c tun.h cmdline.c cmdline.h ippool.c ippool.h radius.h radius.c md5.c md5.h redir.h redir.c dhcp.c dhcp.h syserr.c syserr.h iphash.c iphash.h lookup.c lookup.h remotectrl.c remotectrl.h 
    176176all: all-am 
    177177 
    178178.SUFFIXES: 
  • src/Makefile.in

    a b PROGRAMS = $(sbin_PROGRAMS) 
    5454am_chilli_OBJECTS = chilli.$(OBJEXT) tun.$(OBJEXT) cmdline.$(OBJEXT) \ 
    5555        ippool.$(OBJEXT) radius.$(OBJEXT) md5.$(OBJEXT) \ 
    5656        redir.$(OBJEXT) dhcp.$(OBJEXT) syserr.$(OBJEXT) \ 
    57         iphash.$(OBJEXT) lookup.$(OBJEXT) 
     57        iphash.$(OBJEXT) lookup.$(OBJEXT)  remotectrl.$(OBJEXT) 
    5858chilli_OBJECTS = $(am_chilli_OBJECTS) 
    5959chilli_LDADD = $(LDADD) 
    6060DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir) 
    target_alias = @target_alias@ 
    172172 
    173173# add -pg to enable gprof 
    174174AM_CFLAGS = -D_GNU_SOURCE -fno-builtin -DSBINDIR='"$(sbindir)"'  
    175 chilli_SOURCES = chilli.c defs.h tun.c tun.h cmdline.c cmdline.h ippool.c ippool.h radius.h radius.c md5.c md5.h redir.h redir.c dhcp.c dhcp.h syserr.c syserr.h iphash.c iphash.h lookup.c lookup.h 
     175chilli_SOURCES = chilli.c defs.h tun.c tun.h cmdline.c cmdline.h ippool.c ippool.h radius.h radius.c md5.c md5.h redir.h redir.c dhcp.c dhcp.h syserr.c syserr.h iphash.c iphash.h lookup.c lookup.h remotectrl.c remotectrl.h 
    176176all: all-am 
    177177 
    178178.SUFFIXES: 
  • new file src/remotectrl.c

    - +  
     1#include <stdio.h>           
     2#include <sys/types.h> 
     3#include <sys/socket.h> 
     4#include <netinet/in.h> 
     5#include <errno.h> 
     6 
     7#include "remotectrl.h" 
     8 
     9/* 
     10char *vstrcat(char *first, ...) 
     11{ 
     12        size_t len = 0; 
     13        char *retbuf; 
     14        va_list argp; 
     15        char *p; 
     16        char *tmp=""; 
     17        if(first == NULL) 
     18                first=tmp; 
     19//              return NULL; 
     20         
     21        len = strlen(first); 
     22                 
     23        va_start(argp, first); 
     24 
     25        while((p = va_arg(argp, char *)) != NULL) 
     26                len += strlen(p); 
     27 
     28        va_end(argp); 
     29        retbuf = (char *)malloc(len + 1);       // +1 for trailing \0  
     30 
     31        if(retbuf == NULL) 
     32                return NULL;            // error  
     33 
     34        (void)strcpy(retbuf, first); 
     35 
     36        va_start(argp, first); 
     37 
     38        while((p = va_arg(argp, char *)) != NULL) 
     39                (void)strcat(retbuf, p); 
     40 
     41        va_end(argp); 
     42 
     43        return retbuf; 
     44} 
     45*/ 
     46 
     47int rmtctrl_write_msg( struct rmt_socket_t *sckHnd, uint32_t id, uint32_t extra, char *message ){ 
     48        msg_head_t header; 
     49        int rslt; 
     50        header.id    = id; 
     51        header.len   = strlen(message); 
     52        header.extra = extra; 
     53  rslt = send(sckHnd->fd,&header,sizeof(struct msg_head_t),0); 
     54        if (rslt != -1 && header.len > 0) { 
     55                sckHnd->Tx += rslt; 
     56                rslt = send(sckHnd->fd, message, header.len, 0); 
     57                if (rslt > 0) 
     58                { 
     59                        sckHnd->Tx += rslt; 
     60                        rslt += sizeof(struct msg_head_t); 
     61                } 
     62        } 
     63        return rslt; 
     64} 
     65 
     66int rmtctrl_read_msg( struct rmt_socket_t *sckHnd, msg_head_t *head, char **message ) 
     67{ 
     68//      msg_head_t header; 
     69        int rslt; 
     70        char *buffer; 
     71        int reading = 0; 
     72        int aux = 0; 
     73  rslt = recv(sckHnd->fd, head, sizeof(struct msg_head_t), 0); 
     74        if (rslt == sizeof(struct msg_head_t) ) { 
     75                sckHnd->Rx += rslt; 
     76                *message = (char *)malloc(head->len+1); 
     77                memset(*message,'\0', head->len+1); 
     78                while ( reading < head->len ){ 
     79                        aux = recv(sckHnd->fd, *message, head->len, 0); 
     80                        switch ( aux )  
     81                        { 
     82                                case -1: 
     83                                        switch (errno) 
     84                                        { 
     85                                                case EINTR: 
     86                                                case EAGAIN: 
     87                                                        usleep (100); 
     88                                                        break; 
     89                                                default: 
     90                                                        return -1; 
     91                                        } 
     92                                break; 
     93                                case 0: // mean socket was closed 
     94                                        sckHnd->Rx += reading; 
     95                                        return reading; 
     96                                        break; 
     97                                break; 
     98                                default: 
     99                                        reading+=aux; 
     100                                break; 
     101                        } 
     102                } 
     103/* 
     104                buffer = (char *)malloc(head->len+1); 
     105                while ( reading < head->len ){ 
     106                        memset(buffer,'\0', head->len+1); 
     107                        aux = recv(sckHnd->fd, buffer, head->len, 0); 
     108                        switch ( aux ) { 
     109                                case -1: 
     110                                        switch (errno){ 
     111                                                case EINTR: 
     112                                                case EAGAIN: 
     113                                                        usleep (100); 
     114                                                        break; 
     115                                                default: 
     116                                                        return -1; 
     117                                        } 
     118                                break; 
     119                                case 0: // mean socket was closed 
     120                                        sckHnd->Rx += reading; 
     121                                        return reading; 
     122                                        break; 
     123                                break; 
     124                                default: 
     125                                        if (reading == 0)  
     126                                                *message=(char *)malloc(aux+1); 
     127                                        else 
     128                                                *message=(char*)realloc(*message,(reading+aux+1)*sizeof(char)); 
     129//                                              strcat(*message, buffer); 
     130                                        memcpy(*message+reading, buffer, aux); 
     131                                        reading += aux; 
     132                                        *message[reading]=0; 
     133                        } 
     134                } 
     135                free(buffer); 
     136*/ 
     137                sckHnd->Rx += reading; 
     138                reading += rslt; 
     139                return reading; 
     140        } 
     141        return rslt; 
     142} 
     143 
     144void rmtctrl_newClient(struct rmt_socket_t srv, struct rmt_socket_t *client, int *activeClients) 
     145{ 
     146        int rslt; 
     147        int cli = (*activeClients); 
     148        rmtctrl_accept(srv,&client[cli]); 
     149        if (client[(*activeClients)].fd != -1) 
     150        { 
     151                (*activeClients)++; 
     152        } 
     153        if ((*activeClients) >= MAX_CLIENTS) 
     154        { 
     155                (*activeClients)--; 
     156                rslt = rmtctrl_write_msg(&client[(*activeClients)],MSG_END,0, "Sorry Server is too Busy\n       Try more late\n" ); 
     157                if (rslt > 0) client[(*activeClients)].Tx += rslt; 
     158                rmtctrl_close(&client[(*activeClients)]); 
     159        } 
     160} 
     161 
     162void rmtctrl_close ( struct rmt_socket_t *client ) 
     163{ 
     164        printf("Desde %s se recibieron %d bytes y se enviaron %d bytes\n",inet_ntoa(client->addr.sin_addr),client->Rx,client->Tx); 
     165        close(client->fd); /* cierra fd_rmt_client */ 
     166        printf("Se cerro conexión desde %s\n",inet_ntoa(client->addr.sin_addr) );  
     167        client->fd = -1; 
     168} 
     169 
     170void rmtctrl_accept (struct rmt_socket_t srv, struct rmt_socket_t *client )  
     171{ 
     172        int sin_size=sizeof(struct sockaddr_in); 
     173        int int_Send; 
     174        struct sockaddr_in addr; 
     175         
     176        if ((client->fd = accept(srv.fd,(struct sockaddr *)&client->addr,&sin_size))!=-1)  
     177        { 
     178                client->Rx = 0; 
     179                client->Tx = 0; 
     180                unsigned char c = sizeof(uint32_t); 
     181                int_Send = send(client->fd, &c, 1, 0); 
     182                if (int_Send > 0) client->Tx += int_Send; 
     183                printf("Se abrió una conexión desde %s\n", inet_ntoa(client->addr.sin_addr));  
     184        } 
     185} 
     186 
     187//void cleanClients (int *table, int *n) 
     188void rmtctrl_cleanClients (struct rmt_socket_t *client, int *n) 
     189{ 
     190        int i,j; 
     191 
     192        if ((client == NULL) || ((*n) == 0)) 
     193                return; 
     194 
     195        j=0; 
     196        for (i=0; i<(*n); i++) 
     197        { 
     198                if (client[i].fd != -1) 
     199                { 
     200                        client[j].fd = client[i].fd; 
     201                        client[j].addr = client[i].addr; 
     202                        client[j].Rx = client[i].Rx; 
     203                        client[j].Tx = client[i].Tx; 
     204                        j++; 
     205                } 
     206        } 
     207         
     208        *n = j; 
     209} 
     210 
     211int rmtctrl_maxValue (struct rmt_socket_t *client, int n) 
     212{ 
     213        int i; 
     214        int max; 
     215 
     216        if ((client == NULL) || (n<1)) 
     217                return 0; 
     218                 
     219        max = client[0].fd; 
     220        for (i=0; i<n; i++) 
     221                if (client[i].fd > max) 
     222                        max = client[i].fd; 
     223 
     224        return max; 
     225} 
     226 
     227struct rmt_socket_t rmtctrl_initSrv(struct in_addr rmtlisten, int rmtport){ 
     228        struct rmt_socket_t srv; 
     229        if ((srv.fd=socket(AF_INET, SOCK_STREAM, 0)) == -1 ) {   
     230                printf("error en socket()\n"); 
     231                exit(1); 
     232        } 
     233        srv.addr.sin_family = AF_INET; 
     234        srv.addr.sin_port = htons(rmtport);  
     235        srv.addr.sin_addr.s_addr = rmtlisten.s_addr; 
     236        memset(&(srv.addr.sin_zero), 0, 8);  
     237 
     238        if(bind(srv.fd,(struct sockaddr*)&srv.addr,sizeof(struct sockaddr))==-1) { 
     239                printf("error en bind() \n"); 
     240                exit(-1); 
     241        }      
     242 
     243        if(listen(srv.fd,BACKLOG) == -1) { 
     244                printf("error en listen()\n"); 
     245                exit(-1); 
     246        } 
     247        return srv; 
     248} 
     249 
     250void rmtctrl_srv(struct rmt_socket_t srv, struct rmt_socket_t *client, int *activeClients) 
     251{ 
     252        fd_set fdRead; 
     253        int maxHnd; 
     254        int i; 
     255        struct timeval  nowait;  
     256        memset((char *)&nowait,0,sizeof(nowait));  
     257 
     258        rmtctrl_cleanClients(client, activeClients); 
     259        FD_ZERO (&fdRead); 
     260        FD_SET (srv.fd, &fdRead); 
     261 
     262        for (i=0; i<*activeClients; i++) 
     263                FD_SET (client[i].fd, &fdRead); 
     264 
     265        maxHnd = rmtctrl_maxValue (client, *activeClients); 
     266                 
     267        if (maxHnd < srv.fd) 
     268                maxHnd = srv.fd; 
     269 
     270        select (maxHnd + 1, &fdRead, NULL, NULL,&nowait); 
     271        for (i=0; i<*activeClients; i++) 
     272        { 
     273                if (FD_ISSET (client[i].fd, &fdRead)) 
     274                { 
     275                                rmtctrl_msg_proccess(&client[i]); 
     276                } 
     277        } 
     278        if (FD_ISSET (srv.fd, &fdRead)) 
     279                rmtctrl_newClient(srv,client, &(*activeClients)); 
     280} 
     281 
     282int send_line( struct rmt_socket_t *client, int msg_type, int msg_extra, char *fmt, char *data) 
     283{ 
     284        char str[2048]; 
     285        memset(str,'\0',2048); 
     286        sprintf(str,fmt,data); 
     287        return rmtctrl_write_msg(client,msg_type,msg_extra, str); 
     288} 
     289 
     290int send_octets( struct rmt_socket_t *client, int msg_type, int msg_extra, char *fmt, uint64_t value) 
     291{ 
     292        char *Buffer = (char *)octets2str(value); 
     293        int ret = send_line( client, msg_type, msg_extra, fmt, Buffer); 
     294        free(Buffer); 
     295        return ret; 
     296} 
     297 
     298int send_mac( struct rmt_socket_t *client, int msg_type, int msg_extra, char *fmt, uint8_t *value) 
     299{ 
     300        char *Buffer = (char*)mac2str(value); 
     301        int ret = send_line( client, msg_type, msg_extra, fmt, Buffer); 
     302        free(Buffer); 
     303        return ret; 
     304} 
     305 
     306int send_number( struct rmt_socket_t *client, int msg_type, int msg_extra, char *fmt, uint64_t value) 
     307{ 
     308        char Buffer[64]; 
     309        sprintf(Buffer,"%d", value); 
     310        return send_line( client, msg_type, msg_extra, fmt, Buffer); 
     311} 
     312 
     313const char * mac2str(uint8_t *mac) 
     314{ 
     315        char *buffer; 
     316        buffer=(char*)malloc(18*sizeof(char)); 
     317        memset(buffer,'\0',18); 
     318        (void) sprintf(buffer,"%.2X-%.2X-%.2X-%.2X-%.2X-%.2X", 
     319                    mac[0], mac[1], 
     320                    mac[2], mac[3], 
     321                    mac[4], mac[5]); 
     322        return buffer; 
     323} 
     324 
     325const char * octets2str(uint64_t value) 
     326{ 
     327        char *buffer; 
     328        buffer=(char*)malloc(13*sizeof(char)); 
     329        memset(buffer,'\0',13); 
     330        if (value/8 > 1073741824){ // gigas 
     331                sprintf(buffer,"%.1f(GiB)",((value/8.0)/1073741824.0)); 
     332        }else if (value/8 > 1048576){ // megas 
     333                sprintf(buffer,"%.1f(MiB)",((value/8.0)/1048576.0)); 
     334        }else if (value/8 > 1024){ // KiloBytes 
     335                sprintf(buffer,"%.1f(KiB)",((value/8.0)/1024.0)); 
     336        }else // Bytes 
     337                sprintf(buffer,"%.1f(B)",(value/8)); 
     338        return buffer; 
     339} 
     340 
  • new file src/remotectrl.h

    - +  
     1#include <stdarg.h> 
     2#ifndef _RMTCTRL_H 
     3#define _RMTCTRL_H 
     4 
     5enum  
     6{ 
     7        MSG_OK              = 0, 
     8        MSG_START           = 1, 
     9        MSG_PART            = 2, 
     10        MSG_END             = 3, 
     11        QRY_STATUS          = 100, 
     12        QRY_CONNECTED_LIST      = 101, 
     13        QRY_CONNECTED_FULL_LIST = 102, 
     14        QRY_MACADDR         = 103, 
     15        QRY_IPADDR          = 104, 
     16        QRY_USERNAME        = 105, 
     17 
     18        CMD_AUTHORIZE                           = 200, 
     19        CMD_DISCONNECT                  = 201, 
     20         
     21        EXTRA_ALL_OP                            = 300, 
     22        EXTRA_MAC_OP                            = 301, 
     23        EXTRA_IP_OP                                     = 302, 
     24        EXTRA_USER_OP                           = 303, 
     25}; 
     26 
     27enum 
     28{ 
     29        STRING, 
     30        IP_ADDR, 
     31        MAC_ADDR, 
     32        NUMBER, 
     33        OCTETS, 
     34}; 
     35 
     36#define PORT 15557 /* El puerto que ser? abierto */ 
     37#define BACKLOG 2 /* El n?mero de conexiones permitidas */ 
     38#define MAX_CLIENTS 10 
     39static char CONVERT_BUFF[1024]; 
     40 
     41typedef struct msg_head_t { 
     42        uint32_t id; 
     43        uint32_t extra; 
     44        uint32_t len; 
     45} msg_head_t; 
     46 
     47typedef struct rmt_socket_t { 
     48        int fd; 
     49        struct sockaddr_in addr; 
     50        int Rx; 
     51        int Tx; 
     52} rmt_socket_t; 
     53 
     54//char *vstrcat(char *first, ...); 
     55 
     56         
     57int rmtctrl_write_msg( struct rmt_socket_t *sckHnd, uint32_t id, uint32_t extra, char *message ); 
     58int rmtctrl_read_msg( struct rmt_socket_t *sckHnd, msg_head_t *head, char **message ); 
     59void rmtctrl_newClient(struct rmt_socket_t srv, struct rmt_socket_t *client, int *activeClients); 
     60void rmtctrl_close ( struct rmt_socket_t *client ); 
     61void rmtctrl_accept (struct rmt_socket_t srv, struct rmt_socket_t *client ); 
     62void rmtctrl_cleanClients (struct rmt_socket_t *client, int *n); 
     63 
     64//inicializa las variables y arranca el servidor 
     65struct rmt_socket_t rmtctrl_initSrv(struct in_addr rmtlisten, int rmtport); 
     66//esta funcion es la que va dentro del loop del programa que lo utiliza 
     67void rmtctrl_srv(struct rmt_socket_t srv, struct rmt_socket_t *client, int *activeClients); 
     68//En esta funcion es donde se define como se procesan los mensajes 
     69void rmtctrl_msg_proccess(struct rmt_socket_t *client); 
     70 
     71//char * pepe(char *dest, char *sep, char *src); 
     72 
     73//char * send_value(char *name, char *value, int len, struct in_addr *addr, 
     74//          uint8_t *mac, long int *integer); 
     75//int addfield(char* reg, char *field, char sep); 
     76//int addfield1(char** reg,int rlen, char *field, int flen, char sep); 
     77//int sendConnectedInfo(struct app_conn_t *appconn, struct rmt_socket_t *client);  
     78//const char * value2str( int type, void *value); 
     79const char * octets2str(uint64_t value); 
     80const char * mac2str(uint8_t *mac); 
     81int send_line( struct rmt_socket_t *client, int msg_type, int msg_extra, char *fmt, char *data); 
     82int send_octets( struct rmt_socket_t *client, int msg_type, int msg_extra, char *fmt, uint64_t value); 
     83int send_mac( struct rmt_socket_t *client, int msg_type, int msg_extra, char *fmt, uint8_t *value); 
     84int send_number( struct rmt_socket_t *client, int msg_type, int msg_extra, char *fmt, uint64_t value); 
     85 
     86#endif  /* !_RMTCTRL_H */ 
  • src/Makefile.am

    a b sbin_PROGRAMS = chilli 
    33# add -pg to enable gprof 
    44AM_CFLAGS = -D_GNU_SOURCE -fno-builtin -DSBINDIR='"$(sbindir)"'  
    55 
    6 chilli_SOURCES = chilli.c defs.h tun.c tun.h cmdline.c cmdline.h ippool.c ippool.h radius.h radius.c md5.c md5.h redir.h redir.c dhcp.c dhcp.h syserr.c syserr.h iphash.c iphash.h lookup.c lookup.h 
     6chilli_SOURCES = chilli.c defs.h tun.c tun.h cmdline.c cmdline.h ippool.c ippool.h radius.h radius.c md5.c md5.h redir.h redir.c dhcp.c dhcp.h syserr.c syserr.h iphash.c iphash.h lookup.c lookup.h remotectrl.c remotectrl.h 
    77 
    88# chilli_LDFLAGS = -lcrypt 
    99 
Note: See TracBrowser for help on using the repository browser.