C++ cli_print函数代码示例

/** command "show logging" */
int _dessert_cli_cmd_logging(struct cli_def* cli, char* command, char* argv[], int argc) {
    pthread_rwlock_rdlock(&_dessert_logrbuf_len_lock);
    int i = 0;
    int max = _dessert_logrbuf_len - 1;
    char* line;

    if(_dessert_logrbuf_len < 1) {
        cli_print(
            cli,
            "logging to ringbuffer is disabled - use \"logging ringbuffer [int]\" in config-mode first");
        pthread_rwlock_unlock(&_dessert_logrbuf_len_lock);
        return CLI_ERROR;
    }

    if(argc == 1) {
        int max2 = (int) strtol(argv[0], NULL, 10);

        if(max2 > 0) {
            max = max2;
        }
    }

    /* where to start and print? */
    if(max > _dessert_logrbuf_used) {
        max = _dessert_logrbuf_used;
    }

    i = _dessert_logrbuf_cur - max - 1;

    if(i < 0) {
        i += _dessert_logrbuf_len;
    }

    while(max > 0) {
        i++;
        max--;

        if(i == _dessert_logrbuf_len) {
            i = 0;
        }

        line = _dessert_logrbuf + (DESSERT_LOGLINE_MAX * i);
        cli_print(cli, "%s", line);
    }

    pthread_rwlock_unlock(&_dessert_logrbuf_len_lock);

    return CLI_OK;
}

int cmd_bpdu_pid (struct cli_def *cli, const char *command, char *argv[], int argc)
{
   struct mops_ext_bpdu * pd = clipkt->p_desc;   
   u_int32_t i;
     
   if ( (strcmp(argv[argc-1],"?")==0) || (argc>1) )
     {
	cli_print(cli, "Specify the BPDU port identifier (0..65535)\r");
	cli_print(cli, "\n");
	return CLI_OK;
     }

   if (argc==0)
     {
	cli_print(cli, "Missing argument (use ?)\n");
	return CLI_OK;
     }
   
   i = (u_int32_t) str2int (argv[0]);
   
   if (i>0xffff)
     {
	cli_print(cli, "The port identifier must be within 0..65535\n");
	return CLI_OK;
     }
   
   pd->port_id = (u_int16_t) i;
   
   return CLI_OK;
}

static int process_write(snd_pcm_t* hPlay)
{
    // calculate read chunk size to ensure a entire sample point (all channels)
    // is read
    size_t iReadChunkSize = sizeof(short) * (size_t)channels;
    size_t iNumReadChunks = (unsigned int)fragsize / iReadChunkSize;

    int nread = fread(inputdata, iReadChunkSize, iNumReadChunks, inputfile);
    nread *= (int)iReadChunkSize;
    if (nread <= 0) {
        cli_print("%s: stopping, end of input", __func__);
        return 1;
    }
    if (nread > 0) {
        int nwritten;
        // make it a full frag
        if (nread < fragsize) {
            memset(inputdata + nread, 0, (size_t)(fragsize - nread));
        }
        nwritten = snd_pcm_plugin_write(hPlay, inputdata, (size_t)fragsize);
        if (nwritten != fragsize) {
            cli_print("snd_pcm_plugin_write: %s", snd_strerror(nwritten));
            return 1;
        }
    }
    return 0;
}

int cmd_config_stormcontrol(struct cli_def *cli, char *command, char *argv[], int argc)
{
    if (argc>0){
	if (strcmp(argv[0],"?")==0){
	    cli_print(cli, "  <cr>");
	}else{
	    cli_print(cli, "%% Invalid input detected.");
	}
    }else{
	if (strcasecmp(command,"no storm-control broadcast")==0) {
	    swconfig.port_config_global.config.storm_control_broadcast_disable=1;
	    swconfig.port_config_global.config.storm_control_broadcast_strict=0;
	}
	if (strcasecmp(command,"storm-control broadcast relaxed")==0) {
	    swconfig.port_config_global.config.storm_control_broadcast_disable=0;
	    swconfig.port_config_global.config.storm_control_broadcast_strict=0;
	}
	if (strcasecmp(command,"storm-control broadcast strict")==0) {
	    swconfig.port_config_global.config.storm_control_broadcast_disable=0;
	    swconfig.port_config_global.config.storm_control_broadcast_strict=1;
	}
	if (strcasecmp(command,"no storm-control multicast")==0) {
	    swconfig.port_config_global.config.storm_control_multicast_strict=0;
	}
	if (strcasecmp(command,"storm-control multicast")==0) {
	    swconfig.port_config_global.config.storm_control_multicast_strict=1;
	}
	rtl83xx_setreg16(0x0607,swconfig.port_config_global.raw);
    }
    return CLI_OK;
}

int cli_set_ara_forw_mode(struct cli_def* cli, const char* command, char* argv[], int argc) {
    if(argc != 1) {
        cli_print(cli, "usage %s [BEST, WEIGHTED, RANDOM]", command);
        return CLI_ERROR;
    }

    switch(argv[0][0]) {
        case 'B':
            ara_forw_mode = ARA_FORW_B;
            break;
        case 'W':
            ara_forw_mode = ARA_FORW_W;
            break;
        case 'R':
            ara_forw_mode = ARA_FORW_R;
            break;
        default:
            cli_print(cli, "invalid forward mode: %s", argv[0]);
            dessert_err("invalid forward mode: %s", argv[0]);
            return CLI_ERROR;
    }

    dessert_notice("ara_forw_mode set to %s", ara_forw_mode_strings[ara_forw_mode]);
    return CLI_OK;
}

/**
 * Modify the interval to flush the log file.
 * The log file is flushed every periode.
 *
 * @param argv[0] interval as string, "0" disables flushing
 */
int _dessert_cli_log_interval(struct cli_def* cli, char* command, char* argv[], int argc) {
    if(argc != 1) {
        cli_print(cli, "usage %s INTERVAL\n", command);
        return CLI_ERROR;
    }

    // disable
    if(_dessert_log_flush_periodic) {
        dessert_periodic_del(_dessert_log_flush_periodic);
        _dessert_log_flush_periodic = NULL;
    }

    uint8_t i = (uint8_t) strtoul(argv[0], NULL, 10);

    // enable
    if(i) {
        struct timeval interval;
        interval.tv_sec = i;
        interval.tv_usec = 0;
        struct timeval schedule;
        gettimeofday(&schedule, NULL);
        TIMEVAL_ADD(&schedule, i, 0);

        _dessert_log_flush_periodic = dessert_periodic_add(_dessert_flush_log, NULL, &schedule, &interval);
        cli_print(cli, "log flush interval set to %d seconds\n", i);
        dessert_notice("log flush interval set to %d seconds", i);
    }
    else {
        cli_print(cli, "log flushing disabled\n");
        dessert_notice("log flushing disabled");
    }

    return CLI_OK;
}

int cmd_arp_opcode (struct cli_def *cli, const char *command, char *argv[], int argc)
{
   struct mops_ext_arp * pd = clipkt->p_desc;
  
   if ( (strncmp(argv[argc-1],"?",1)==0) || (argc!=1) )
     {
	cli_print(cli,"Specify the ARP operation code (0-ffff)\n");
	cli_print(cli,"Optional keywords: 'request' (default) or 'response'\n");
     }
   else if (mz_strcmp(argv[0],"request", 3)==0)
     {
	cli_print(cli, "Set ARP mode to request\n");
	pd->opcode = 1;
     }
   else if (mz_strcmp(argv[0],"response", 3)==0)
     {
	cli_print(cli, "Set ARP mode to response\n");
	pd->opcode = 2;
     }
   else
     {
	cli_print(cli, "Invalid ARP mode\n");
     }
   
   return CLI_OK;
}

int cli_set_ara_ack_mode(struct cli_def* cli, const char* command, char* argv[], int argc) {
    if(argc != 1) {
        cli_print(cli, "usage %s [LINK, PASSIVE, NETWORK, DISABLED]", command);
        return CLI_ERROR;
    }

    switch(argv[0][0]) {
        case 'L':
            // TODO implement mode
            dessert_err("mode not yet implemented");
            break;
            ara_ack_mode = ARA_ACK_LINK;
            break;
        case 'P':
            ara_ack_mode = ARA_ACK_PASSIVE;
            break;
        case 'N':
            ara_ack_mode = ARA_ACK_NETWORK;
            break;
        case 'D':
            ara_ack_mode = ARA_ACK_DISABLED;
            break;
        default:
            cli_print(cli, "invalid acknowledgement mode: %s", argv[0]);
            dessert_err("invalid acknowledgement mode: %s", argv[0]);
            return CLI_ERROR;
    }

    dessert_notice("ara_ack_mode set to %s", ara_ack_mode_strings[ara_ack_mode]);
    return CLI_OK;
}

int cmd_bpdu_vlan(struct cli_def *cli, const char *command, char *argv[], int argc)
{
   u_int32_t i;
   
   if ( (strcmp(argv[argc-1],"?")==0) || (argc>1) )
     {
	cli_print(cli, "Specify the VLAN number for PVST+ messages (0..4095)\n");
	cli_print(cli, "\n");
	return CLI_OK;
     }
   
   if (argc==0)
     {
	cli_print(cli, "Missing argument (use ?)\n");
	return CLI_OK;
     }

   i = (u_int32_t) str2int(argv[0]);
   
   if (i>65535)
     {
	cli_print(cli, "VLAN number is definitely too large! (0..65535 at maximum)\n");
	return CLI_OK;
     }

   if (i>4095)
     {
	cli_print(cli, "Warning: Invalid VLAN number (0..4095) - but let's try it...\n");
     }
   
   mops_create_bpdu_trailer(clipkt, (u_int16_t) i);
   
   return CLI_OK;
}

int cmd_bpdu_pc (struct cli_def *cli, const char *command, char *argv[], int argc)
{
   struct mops_ext_bpdu * pd = clipkt->p_desc;   
   unsigned long long int i;
   
   if ( (strcmp(argv[argc-1],"?")==0) || (argc>1) )
     {
	cli_print(cli, "Specify the BPDU root path cost (0..4294967295)\r");
	cli_print(cli, "\n");
	return CLI_OK;
     }

   if (argc==0)
     {
	cli_print(cli, "Missing argument (use ?)\n");
	return CLI_OK;
     }
   
   i = str2lint (argv[0]);
   if (i>0xffffffff)
     {
	cli_print(cli, "Range exceeded (0..4294967295)\n");
     }
   else
     pd->root_pc = (u_int32_t) i;
     
   return CLI_OK;
}

int cmd_config_qos_wrr_queue_ratio(struct cli_def *cli, char *command, char *argv[], int argc)
{
    if (argc>0){
	if (strcmp(argv[0],"?")==0){
	    int i;
	    for (i=0;i<4;i++){
		cli_print(cli, "%s",wrr_ratio_text[i]);
	    }
	}else{
	    int i,hit;
	    hit=0;
	    for (i=0;i<4;i++){
		if (strcmp(wrr_ratio_text[i],argv[0])==0){
		    swconfig.qos_config.config.wrr_ratio=i;
		    hit=1;
		}
	    }
	    if (hit){
		rtl83xx_setreg16(0x0400,swconfig.qos_config.raw);
	    }else{
		cli_print(cli, "%% Invalid input detected.");
	    }
	}
    }else{
	cli_print(cli, "%% Please specify ratio");
    }
    return CLI_OK;
}

//*****************************************************************************
// execute callback for microrl library
// do what you want here, but don't write to argv!!! read only!!
int execute (int argc, const char * const * argv){
  if (recursive_execute(argc, argv, chibiutils) == -1){
    cli_print ("command: '");
    cli_print ((char*)argv[0]);
    cli_print ("' Not found.\n\r");
  }
  return 0;
}

int cli_show_prune_routes(struct cli_def* cli, const char* command, char* argv[], int argc) {
    if(ara_prune_routes) {
        cli_print(cli, "altervative routes that are more than %04.02lf times longer than the shortest path are not accepted", ara_prune_routes);
    }
    else {
        cli_print(cli, "route pruning is disabled");
    }

    return CLI_OK;
}

int cli_show_pant_interval(struct cli_def* cli, const char* command, char* argv[], int argc) {
    if(ara_pant_interval) {
        cli_print(cli, "PANT interval is set to %d seconds", ara_pant_interval);
    }
    else {
        cli_print(cli, "PANTs are disabled");
    }

    return CLI_OK;
}

int cli_show_ara_print_rt_periodic(struct cli_def* cli, char* command, char* argv[], int argc) {
    if(ara_print_rt_interval_s) {
        cli_print(cli, "routing table is printed every %d seconds", ara_print_rt_interval_s);
    }
    else {
        cli_print(cli, "routing table is not printed periodically");
    }

    return CLI_OK;
}