hades2013
hades2013

mtk 的uci2dat工具

https://github.com/Nossiac/mtk-openwrt-feeds
中给出了一个名为uci2dat的插件并作出了如下描述：

uci2dat
An application that translates "/etc/config/wireless" into MTK's WiFi profiles (e.g. mt7620.dat). You may use it as an adapter to make MTK's WiFi drivers work with standard LuCi's WiFi management.

标准luci的无线配置用这个配置文件/etc/config/wireless，而mtk的无线驱动使用mt7620.dat这个配置文件
这两种配置文件格式不同，这就需要来转一下格式，uci2dat这个插件就实现了这个功能

uci2dat源码如下

/*****************************************************************************
 * $File:   uci2dat.c
 *
 * $Author: Hua Shao
 * $Date:   Feb, 2014
 *
 * Boring, Boring, Boring, Boring, Boring........
 *
 *****************************************************************************/


#include 
#include 
#include 
#include 
#include 
#include 

#include 


#ifdef OK
#undef OK
#endif
#define OK (0)

#ifdef NG
#undef NG
#endif
#define NG (-1)

#ifdef SHDBG
#undef SHDBG
#endif
#define SHDBG(...)   printf(__VA_ARGS__);
#define DEVNUM_MAX (4)
#define MBSSID_MAX (4)


#define FPRINT(fp, e, ...) \
            do {\
                char buffer[128] = {0}; \
                printf("%s(),%s=", __FUNCTION__, e->dat_key); \
                snprintf(buffer, sizeof(buffer), __VA_ARGS__); \
                if (strlen(buffer) == 0) { \
                    fprintf(fp, "%s", e->defvalue?e->defvalue:""); \
                    printf("%s", ""); \
                } \
                else { \
                    fprintf(fp, "%s", buffer); \
                    printf("%s", buffer); \
                } \
                printf(", def=\"%s\"\n", e->defvalue?e->defvalue:""); \
            }while(0)


#define WIFI_UCI_FILE "/etc/config/wireless"

#define PARSE_UCI_OPTION(dst, src) \
    do { \
        src = NULL; \
        src = uci_lookup_option_string(uci_ctx, s, dst.uci_key); \
        if(src) { \
            strncpy(dst.value, src, sizeof(dst.value)); \
            printf("%s(),    %s=%s\n", __FUNCTION__, dst.uci_key, dst.value); \
        } \
    }while(0)


struct _param;

typedef void (*ucihook)(FILE *,struct _param *, const char * devname);

typedef struct  _param
{
    const char *    dat_key;
    const char *    uci_key;
    char            value[128];
    ucihook         hook;
    const char *    defvalue;
} param;

typedef struct _vif
{
    param ssid;
    param authmode;        /* wep, wpa, ... */
    param hidden;          /* Hidden SSID */
    param cipher;          /* ccmp(aes),tkip */
    param key;             /* wpa psk */

    param wepkey[4];       /* wep key, ugly, yep! */

    param auth_server;
    param auth_port;
    param auth_secret;
    param rekeyinteval;
    param preauth;
    param pmkcacheperiod;
} vif;

typedef struct
{
    char    devname[16];
    param * params;
    int     vifnum;
    vif     vifs[MBSSID_MAX];
} wifi_params;

void hooker(FILE * fp, param * p, const char * devname);

/* these are separated from CFG_ELEMENTS because they
   use a different represention structure.
*/
vif VIF =
{
    .ssid               = {NULL, "ssid", {0}, NULL,  NULL},
    .authmode           = {NULL, "encryption", {0}, NULL,  NULL},
    .hidden             = {NULL, "hidden", {0}, NULL,  NULL},
    .cipher             = {NULL, "cipher", {0}, NULL,  NULL},

    /* wpa key, or wep key index */
    .key                = {NULL, "key", {0}, NULL,  NULL},

    /* wep key group */
    .wepkey             = {{NULL, "key1", {0}, NULL,  NULL},
                           {NULL, "key2", {0}, NULL,  NULL},
                           {NULL, "key3", {0}, NULL,  NULL},
                           {NULL, "key4", {0}, NULL,  NULL}},

    /* wpa & 8021x */
    .auth_server        = {NULL, "auth_server", "0", NULL,  NULL},
    .auth_port          = {NULL, "auth_port", "1812", NULL,  NULL},
    .auth_secret        = {NULL, "auth_secret", {0}, NULL,  NULL},
    .pmkcacheperiod     = {NULL, "pmkcacheperiod", {0}, NULL,  NULL},
    .preauth            = {NULL, "preauth", {0}, NULL,  NULL},
    .rekeyinteval       = {NULL, "rekeyinteval", {0}, NULL,  NULL},
};

param CFG_ELEMENTS[] =
{
    /* Default configurations described in :
           MTK_Wi-Fi_SoftAP_Software_Programmming_Guide_v3.6.pdf
    */
    {"CountryRegion", "region", {0}, hooker,  "1"},
    {"CountryRegionABand", "aregion", {0}, hooker, "7"},
    {"CountryCode", "country", {0}, hooker, NULL},
    {"BssidNum", NULL, {0}, hooker,  "1"},
    {"SSID1", NULL, {0}, hooker,  "OpenWrt"},
    {"SSID2", NULL, {0}, hooker,  NULL},
    {"SSID3", NULL, {0}, hooker,  NULL},
    {"SSID4", NULL, {0}, hooker,  NULL},
    {"WirelessMode", "wifimode", {0}, hooker,  "9"},
    {"TxRate", "txrate", {0}, hooker, "0"},
    {"Channel", "channel", {0}, hooker,  "0"},
    {"BasicRate", "basicrate", {0}, hooker, "15"},
    {"BeaconPeriod", "beacon", {0}, hooker,  "100"},
    {"DtimPeriod", "dtim", {0}, hooker,  "1"},
    {"TxPower", "txpower", {0}, hooker,  "100"},
    {"DisableOLBC", "disolbc", {0}, hooker, "0"},
    {"BGProtection", "bgprotect", {0}, hooker,  "0"},
    {"TxAntenna", "txantenna", {0}, hooker, NULL},
    {"RxAntenna", "rxantenna", {0}, hooker, NULL},
    {"TxPreamble", "txpreamble", {0}, hooker,  "0"},
    {"RTSThreshold", "rtsthres", {0}, hooker,  "2347"},
    {"FragThreshold", "fragthres", {0}, hooker,  "2346"},
    {"TxBurst", "txburst", {0}, hooker,  "1"},
    {"PktAggregate", "pktaggre", {0}, hooker,  "0"},
    {"TurboRate", "turborate", {0}, hooker, "0"},
    {"WmmCapable", "wmm", {0}, hooker, "1"},
    {"APSDCapable", "apsd", {0}, hooker, "1"},
    {"DLSCapable", "dls", {0}, hooker, "0"},
    {"APAifsn", "apaifsn", {0}, hooker, "3;7;1;1"},
    {"APCwmin", "apcwmin", {0}, hooker, "4;4;3;2"},
    {"APCwmax", "apcwmax", {0}, hooker, "6;10;4;3"},
    {"APTxop", "aptxop", {0}, hooker, "0;0;94;47"},
    {"APACM", "apacm", {0}, hooker, "0;0;0;0"},
    {"BSSAifsn", "bssaifsn", {0}, hooker, "3;7;2;2"},
    {"BSSCwmin", "bsscwmin", {0}, hooker, "4;4;3;2"},
    {"BSSCwmax", "bsscwmax", {0}, hooker, "10;10;4;3"},
    {"BSSTxop", "bsstxop", {0}, hooker, "0;0;94;47"},
    {"BSSACM", "bssacm", {0}, hooker, "0;0;0;0"},
    {"AckPolicy", "ackpolicy", {0}, hooker, "0;0;0;0"},
    {"NoForwarding", "noforward", {0}, hooker, "0"},
    {"NoForwardingBTNBSSID", NULL, {0}, NULL, "0"},
    {"HideSSID", "hidden", {0}, hooker,  "0"},
    {"StationKeepAlive", NULL, {0}, NULL, "0"},
    {"ShortSlot", "shortslot", {0}, hooker,  "1"},
    {"AutoChannelSelect", "channel", {0}, hooker, "2"},
    {"IEEE8021X", "ieee8021x", {0}, hooker, "0"},
    {"IEEE80211H", "ieee80211h", {0}, hooker, "0"},
    {"CSPeriod", "csperiod", {0}, hooker, "10"},
    {"WirelessEvent", "wirelessevent", {0}, hooker, "0"},
    {"IdsEnable", "idsenable", {0}, hooker, "0"},
    {"AuthFloodThreshold", NULL, {0}, NULL, "32"},
    {"AssocReqFloodThreshold", NULL, {0}, NULL, "32"},
    {"ReassocReqFloodThreshold", NULL, {0}, NULL, "32"},
    {"ProbeReqFloodThreshold", NULL, {0}, NULL, "32"},
    {"DisassocFloodThreshold", NULL, {0}, NULL, "32"},
    {"DeauthFloodThreshold", NULL, {0}, NULL, "32"},
    {"EapReqFooldThreshold", NULL, {0}, NULL, "32"},
    {"PreAuth", "preauth", {0}, hooker, "0"},
    {"AuthMode", NULL, {0}, hooker,  "OPEN"},
    {"EncrypType", NULL, {0}, hooker,  "NONE"},
    {"RekeyInterval", "rekeyinteval", {0}, hooker, "0"},
    {"PMKCachePeriod", "pmkcacheperiod", {0}, hooker, "10"},
    {"WPAPSK1", NULL, {0}, hooker,  NULL},
    {"WPAPSK2", NULL, {0}, hooker,  NULL},
    {"WPAPSK3", NULL, {0}, hooker,  NULL},
    {"WPAPSK4", NULL, {0}, hooker,  NULL},
    {"DefaultKeyID", NULL, {0}, hooker, "1"},
    {"Key1Type", NULL, {0}, hooker, "1"},
    {"Key1Str1", NULL, {0}, hooker, NULL},
    {"Key1Str2", NULL, {0}, hooker, NULL},
    {"Key1Str3", NULL, {0}, hooker, NULL},
    {"Key1Str4", NULL, {0}, hooker, NULL},
    {"Key2Type", NULL, {0}, hooker, "1"},
    {"Key2Str1", NULL, {0}, hooker, NULL},
    {"Key2Str2", NULL, {0}, hooker, NULL},
    {"Key2Str3", NULL, {0}, hooker, NULL},
    {"Key2Str4", NULL, {0}, hooker, NULL},
    {"Key3Type", NULL, {0}, hooker, "1"},
    {"Key3Str1", NULL, {0}, hooker, NULL},
    {"Key3Str2", NULL, {0}, hooker, NULL},
    {"Key3Str3", NULL, {0}, hooker, NULL},
    {"Key3Str4", NULL, {0}, hooker, NULL},
    {"Key4Type", NULL, {0}, hooker, "1"},
    {"Key4Str1", NULL, {0}, hooker, NULL},
    {"Key4Str2", NULL, {0}, hooker, NULL},
    {"Key4Str3", NULL, {0}, hooker, NULL},
    {"Key4Str4", NULL, {0}, hooker, NULL},
    {"AccessPolicy0", NULL, {0}, NULL, "0"},
    {"AccessControlList0", NULL, {0}, NULL, NULL},
    {"AccessPolicy1", NULL, {0}, NULL, "0"},
    {"AccessControlList1", NULL, {0}, NULL, NULL},
    {"AccessPolicy2", NULL, {0}, NULL, "0"},
    {"AccessControlList2", NULL, {0}, NULL, NULL},
    {"AccessPolicy3", NULL, {0}, NULL, "0"},
    {"AccessControlList3", NULL, {0}, NULL, NULL},
    {"WdsEnable", "wds_enable", {0}, hooker, "0"},
    {"WdsEncrypType", "wds_enctype", {0}, hooker, "NONE"},
    {"WdsList", NULL, {0}, NULL, NULL},
    {"Wds0Key", NULL, {0}, NULL, NULL},
    {"Wds1Key", NULL, {0}, NULL, NULL},
    {"Wds2Key", NULL, {0}, NULL, NULL},
    {"Wds3Key", NULL, {0}, NULL, NULL},
    {"RADIUS_Server", "auth_server", {0}, hooker, NULL},
    {"RADIUS_Port", "auth_port", {0}, hooker, NULL},
    {"RADIUS_Key1", "radius_key1", {0}, hooker, NULL},
    {"RADIUS_Key2", "radius_key2", {0}, hooker, NULL},
    {"RADIUS_Key3", "radius_key2", {0}, hooker, NULL},
    {"RADIUS_Key4", "radius_key4", {0}, hooker, NULL},
    {"own_ip_addr", "own_ip_addr", {0}, hooker, "192.168.5.234"},
    {"EAPifname", "eapifname", {0}, hooker, NULL},
    {"PreAuthifname", "preauthifname", {0}, hooker, "br-lan"},
    {"HT_HTC", "ht_htc", {0}, hooker, "0"},
    {"HT_RDG", "ht_rdg", {0}, hooker,  "0"},
    {"HT_EXTCHA", "ht_extcha", {0}, hooker, "0"},
    {"HT_LinkAdapt", "ht_linkadapt", {0}, hooker, "0"},
    {"HT_OpMode", "ht_opmode", {0}, hooker, "0"},
    {"HT_MpduDensity", NULL, {0}, hooker, "5"},
    {"HT_BW", "bw", {0}, hooker,  "0"},
    {"VHT_BW", "bw", {0}, hooker,  "0"},
    {"VHT_SGI", "vht_sgi", {0}, hooker,  "1"},
    {"VHT_STBC", "vht_stbc", {0}, hooker, "0"},
    {"VHT_BW_SIGNAL", "vht_bw_sig", {0}, hooker,  "0"},
    {"VHT_DisallowNonVHT", "vht_disnonvht", {0}, hooker, NULL},
    {"VHT_LDPC", "vht_ldpc", {0}, hooker, "1"},
    {"HT_AutoBA", "ht_autoba", {0}, hooker, "1"},
    {"HT_AMSDU", "ht_amsdu", {0}, hooker, NULL},
    {"HT_BAWinSize", "ht_bawinsize", {0}, hooker, "64"},
    {"HT_GI", "ht_gi", {0}, hooker,  "1"},
    {"HT_MCS", "ht_mcs", {0}, hooker, "33"},
    {"WscManufacturer", "wscmanufacturer", {0}, hooker, NULL},
    {"WscModelName", "wscmodelname", {0}, hooker, NULL},
    {"WscDeviceName", "wscdevicename", {0}, hooker, NULL},
    {"WscModelNumber", "wscmodelnumber", {0}, hooker, NULL},
    {"WscSerialNumber", "wscserialnumber", {0}, hooker, NULL},

    /* Extra configurations found in 76x2e */
    {"FixedTxMode", "fixedtxmode", {0}, hooker, "0"},
    {"AutoProvisionEn", "autoprovision", {0}, hooker, "0"},
    {"FreqDelta", "freqdelta", {0}, hooker, "0"},
    {"CarrierDetect", "carrierdetect", {0}, hooker, "0"},
    {"ITxBfEn", "itxbf", {0}, hooker, "0"},
    {"PreAntSwitch", "preantswitch", {0}, hooker, "1"},
    {"PhyRateLimit", "phyratelimit", {0}, hooker, "0"},
    {"DebugFlags", "debugflags", {0}, hooker, "0"},
    {"ETxBfEnCond", NULL, {0}, NULL, "0"},
    {"ITxBfTimeout", NULL, {0}, NULL, "0"},
    {"ETxBfNoncompress", NULL, {0}, NULL, "0"},
    {"ETxBfIncapable", NULL, {0}, NULL, "0"},
    {"FineAGC", "fineagc", {0}, hooker, "0"},
    {"StreamMode", "streammode", {0}, hooker, "0"},
    {"StreamModeMac0", NULL, {0}, NULL, NULL},
    {"StreamModeMac1", NULL, {0}, NULL, NULL},
    {"StreamModeMac2", NULL, {0}, NULL, NULL},
    {"StreamModeMac3", NULL, {0}, NULL, NULL},
    {"RDRegion", NULL, {0}, NULL, NULL},
    {"DfsLowerLimit", "dfs_lowlimit", {0}, hooker, "0"},
    {"DfsUpperLimit", "dfs_uplimit", {0}, hooker, "0"},
    {"DfsOutdoor", "dfs_outdoor", {0}, hooker, "0"},
    {"SymRoundFromCfg", NULL, {0}, NULL, "0"},
    {"BusyIdleFromCfg", NULL, {0}, NULL, "0"},
    {"DfsRssiHighFromCfg", NULL, {0}, NULL, "0"},
    {"DfsRssiLowFromCfg", NULL, {0}, NULL, "0"},
    {"DFSParamFromConfig", NULL, {0}, NULL, "0"},
    {"FCCParamCh0", NULL, {0}, NULL, NULL},
    {"FCCParamCh1", NULL, {0}, NULL, NULL},
    {"FCCParamCh2", NULL, {0}, NULL, NULL},
    {"FCCParamCh3", NULL, {0}, NULL, NULL},
    {"CEParamCh0", NULL, {0}, NULL, NULL},
    {"CEParamCh1", NULL, {0}, NULL, NULL},
    {"CEParamCh2", NULL, {0}, NULL, NULL},
    {"CEParamCh3", NULL, {0}, NULL, NULL},
    {"JAPParamCh0", NULL, {0}, NULL, NULL},
    {"JAPParamCh1", NULL, {0}, NULL, NULL},
    {"JAPParamCh2", NULL, {0}, NULL, NULL},
    {"JAPParamCh3", NULL, {0}, NULL, NULL},
    {"JAPW53ParamCh0", NULL, {0}, NULL, NULL},
    {"JAPW53ParamCh1", NULL, {0}, NULL, NULL},
    {"JAPW53ParamCh2", NULL, {0}, NULL, NULL},
    {"JAPW53ParamCh3", NULL, {0}, NULL, NULL},
    {"FixDfsLimit", "fixdfslimit", {0}, hooker, "0"},
    {"LongPulseRadarTh", "lpsradarth", {0}, hooker, "0"},
    {"AvgRssiReq", "avgrssireq", {0}, hooker, "0"},
    {"DFS_R66", "dfs_r66", {0}, hooker, "0"},
    {"BlockCh", "blockch", {0}, hooker, NULL},
    {"GreenAP", "greenap", {0}, hooker, "0"},
    {"WapiPsk1", NULL, {0}, NULL, NULL},
    {"WapiPsk2", NULL, {0}, NULL, NULL},
    {"WapiPsk3", NULL, {0}, NULL, NULL},
    {"WapiPsk4", NULL, {0}, NULL, NULL},
    {"WapiPsk5", NULL, {0}, NULL, NULL},
    {"WapiPsk6", NULL, {0}, NULL, NULL},
    {"WapiPsk7", NULL, {0}, NULL, NULL},
    {"WapiPsk8", NULL, {0}, NULL, NULL},
    {"WapiPskType", NULL, {0}, NULL, NULL},
    {"Wapiifname", NULL, {0}, NULL, NULL},
    {"WapiAsCertPath", NULL, {0}, NULL, NULL},
    {"WapiUserCertPath", NULL, {0}, NULL, NULL},
    {"WapiAsIpAddr", NULL, {0}, NULL, NULL},
    {"WapiAsPort", NULL, {0}, NULL, NULL},
    {"RekeyMethod", "rekeymethod", {0}, hooker, "TIME"},
    {"MeshAutoLink", "mesh_autolink", {0}, hooker, "0"},
    {"MeshAuthMode", "mesh_authmode", {0}, hooker, NULL},
    {"MeshEncrypType", "mesh_enctype", {0}, hooker, NULL},
    {"MeshDefaultkey", "mesh_defkey", {0}, hooker, "0"},
    {"MeshWEPKEY", "mesh_wepkey", {0}, hooker, NULL},
    {"MeshWPAKEY", "mesh_wpakey", {0}, hooker, NULL},
    {"MeshId", "mesh_id", {0}, hooker, NULL},
    {"HSCounter", "hscount", {0}, hooker, "0"},
    {"HT_BADecline", "ht_badec", {0}, hooker, "0"},
    {"HT_STBC", "ht_stbc", {0}, hooker, "0"},
    {"HT_LDPC", "ht_ldpc", {0}, hooker, "1"},
    {"HT_TxStream", "ht_txstream", {0}, hooker, "1"},
    {"HT_RxStream", "ht_rxstream", {0}, hooker, "1"},
    {"HT_PROTECT", "ht_protect", {0}, hooker, "1"},
    {"HT_DisallowTKIP", "ht_distkip", {0}, hooker, "0"},
    {"HT_BSSCoexistence", "ht_bsscoexist", {0}, hooker, "0"},
    {"WscConfMode", "wsc_confmode", {0}, hooker, "0"},
    {"WscConfStatus", "wsc_confstatus", {0}, hooker, "2"},
    {"WCNTest", "wcntest", {0}, hooker, "0"},
    {"WdsPhyMode", "wds_phymode", {0}, hooker, NULL},
    {"RADIUS_Acct_Server", "radius_acctserver", {0}, hooker, NULL},
    {"RADIUS_Acct_Port", "radius_acctport", {0}, hooker, "1813"},
    {"RADIUS_Acct_Key", "radius_acctkey", {0}, hooker, NULL},
    {"Ethifname", "ethifname", {0}, hooker, NULL},
    {"session_timeout_interval", "session_intv", {0}, hooker, "0"},
    {"idle_timeout_interval", "idle_intv", {0}, hooker, "0"},
    {"WiFiTest", NULL, {0}, NULL, "0"},
    {"TGnWifiTest", "tgnwifitest", {0}, hooker, "0"},
    {"ApCliEnable", NULL, {0}, NULL, "0"},
    {"ApCliSsid", NULL, {0}, NULL, NULL},
    {"ApCliBssid", NULL, {0}, NULL, NULL},
    {"ApCliAuthMode", NULL, {0}, NULL, NULL},
    {"ApCliEncrypType", NULL, {0}, NULL, NULL},
    {"ApCliWPAPSK", NULL, {0}, NULL, NULL},
    {"ApCliDefaultKeyID", NULL, {0}, NULL, "0"},
    {"ApCliKey1Type", NULL, {0}, NULL, "0"},
    {"ApCliKey1Str", NULL, {0}, NULL, NULL},
    {"ApCliKey2Type", NULL, {0}, NULL, "0"},
    {"ApCliKey2Str", NULL, {0}, NULL, NULL},
    {"ApCliKey3Type", NULL, {0}, NULL, "0"},
    {"ApCliKey3Str", NULL, {0}, NULL, NULL},
    {"ApCliKey4Type", NULL, {0}, NULL, "0"},
    {"ApCliKey4Str", NULL, {0}, NULL, NULL},
    {"EfuseBufferMode", "efusebufmode", {0}, hooker, "0"},
    {"E2pAccessMode", "e2paccmode", {0}, hooker, "2"},
    {"RadioOn", "radio", {0}, hooker, "1"},
    {"BW_Enable", "bw_enable", {0}, hooker, "0"},
    {"BW_Root", "bw_root", {0}, hooker, "0"},
    {"BW_Priority", "bw_priority", {0}, hooker, NULL},
    {"BW_Guarantee_Rate", "bw_grtrate", {0}, hooker, NULL},
    {"BW_Maximum_Rate", "bw_maxrate", {0}, hooker, NULL},

    /* add more configurations */
    {"AutoChannelSkipList", "autoch_skip", {0}, hooker, NULL},
    {"WscConfMethod", "wsc_confmethod", {0}, hooker, NULL},
    {"WscKeyASCII", "wsc_keyascii", {0}, hooker, NULL},
    {"WscSecurityMode", "wsc_security", {0}, hooker, NULL},
    {"Wsc4digitPinCode", "wsc_4digitpin", {0}, hooker, NULL},
    {"WscVendorPinCode", "wsc_vendorpin", {0}, hooker, NULL},
    {"WscV2Support", "wsc_v2", {0}, hooker, NULL},

};

static struct uci_context * uci_ctx;
static struct uci_package * uci_wireless;
static wifi_params wifi_cfg[DEVNUM_MAX];


char * __get_value(char * datkey)
{
    int i;

    for(i=0; idat_key, p->uci_key,
                   p->value[0]?p->value:"(null)", p->hook?"Y":"-", p->defvalue);
        }
    }
    return NULL;
}


void parse_dat(char * devname, char * datpath)
{
    FILE * fp = NULL;
    char buffer[128] = {0};
    char k[32] = {0};
    char v[32] = {0};
    int i = 0, n = 0;
    char * p = NULL;
    char * q = NULL;
    wifi_params * cfg = NULL;

    printf("API: %s(%s, %s)\n", __FUNCTION__, devname, datpath);

    for (i=0; iparams[n].value, v, sizeof(CFG_ELEMENTS[n].value));
                break;
            }
        }
        if (n >= sizeof(CFG_ELEMENTS)/sizeof(CFG_ELEMENTS[0]))
            printf("!!! <%s> not supported\n", k);
        else
            printf("<%s>=<%s>\n", k, v);

    }
    while(1);

#if 0
    /* dump and check */
    for ( n=0; nparams[n].value)>0)
            printf("inited: <%s>=<%s>\n", CFG_ELEMENTS[n].dat_key, cfg->params[n].value);
        else
            printf("empty : <%s>=<%s>\n", CFG_ELEMENTS[n].dat_key, cfg->params[n].value);
    }
#endif

__error:
    if(fp) fclose(fp);

    return;
}


void parse_uci(char * arg)
{
    struct uci_element *e   = NULL;
    const char * value = NULL;
    int i = 0;
    int cur_dev, cur_vif;

    printf("API: %s(%s)\n", __FUNCTION__, arg);
    if (!uci_wireless || !uci_ctx)
    {
        printf("%s() uci context not ready!\n", __FUNCTION__);
        return;
    }

    /* scan wireless devices ! */
    uci_foreach_element(&uci_wireless->sections, e)
    {
        struct uci_section *s = uci_to_section(e);

        if(0 == strcmp(s->type, "wifi-device"))
        {
            printf("%s(), wifi-device: %s\n", __FUNCTION__, s->e.name);
            for(cur_dev=0; cur_deve.name, wifi_cfg[cur_dev].devname))
                    break;
            }

            if(cur_dev>=DEVNUM_MAX)
            {
                printf("%s(), device (%s) not found!\n", __FUNCTION__, s->e.name);
                break;
            }

            for( i = 0; isections, e)
    {
        struct uci_section *s = uci_to_section(e);
        if(0 == strcmp(s->type, "wifi-iface"))
        {
            value = NULL;
            value = uci_lookup_option_string(uci_ctx, s, "device");
            for(cur_dev=0; cur_dev= DEVNUM_MAX)
            {
                printf("%s(), device (%s) not found!\n", __FUNCTION__, value);
                break;
            }
            value = NULL;
            value = uci_lookup_option_string(uci_ctx, s, "ifname");
            printf("%s(), wifi-iface: %s\n", __FUNCTION__, value);

            cur_vif = wifi_cfg[cur_dev].vifnum;

            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].ssid, value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].hidden, value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].key, value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].wepkey[0], value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].wepkey[1], value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].wepkey[2], value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].wepkey[3], value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].auth_server, value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].auth_port, value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].auth_secret, value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].rekeyinteval, value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].preauth, value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].pmkcacheperiod, value);
#if 0
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].authmode, value);
            PARSE_UCI_OPTION(wifi_cfg[cur_dev].vifs[cur_vif].cipher, value);
#else
#define STRNCPPP(dst,src) \
                do {\
                    strncpy(dst.value, src, sizeof(dst.value)); \
                    printf("%s(),    %s=%s\n", __FUNCTION__, dst.uci_key, src); \
                } while(0)

            /* cipher */
            value = uci_lookup_option_string(uci_ctx, s, "encryption");
            if(value)
            {
                const char * p = NULL;
                if (0 == strncmp("8021x", value, strlen("8021x")))
                {
                    STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "8021x");
                    STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].cipher, "wep");
                }

                if (0 == strncmp("none", value, strlen("none")))
                {
                    STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "none");
                    STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].cipher, "NONE");
                }
                else if (0 == strncmp("wep-open", value, strlen("wep-open")))
                {
                    STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "wep-open");
                    STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].cipher, "wep");
                }
                else if (0 == strncmp("wep-shared", value, strlen("wep-shared")))
                {
                    STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "wep-shared");
                    STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].cipher, "wep");
                }
                else if (0 == strncmp("mixed-psk", value, strlen("mixed-psk")))
                {
                    STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "psk-mixed");
                    p = value+strlen("mixed-psk");
                    if (*p == '+' && *(p+1) != 0)
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].cipher, p+1);
                    else
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].cipher, "tkip+ccmp");
                }
                else if(0 == strncmp("psk", value, strlen("psk")))
                {
                    if (0 == strncmp("psk-mixed", value, strlen("psk-mixed")))
                    {
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "psk-mixed");
                        p = value+strlen("psk-mixed");
                    }
                    else if (0 == strncmp("psk+psk2", value, strlen("psk+psk2")))
                    {
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "psk-mixed");
                        p = value+strlen("psk+psk2");
                    }
                    else if (0 == strncmp("psk2", value, strlen("psk2")))
                    {
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "psk2");
                        p = value+strlen("psk2");
                    }
                    else if (0 == strncmp("psk", value, strlen("psk")))
                    {
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "psk");
                        p = value+strlen("psk");
                    }

                    if (*p == '+' && *(p+1) != 0)
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].cipher, p+1);
                    else
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].cipher, "tkip+ccmp");
                }
                else if(0 == strncmp("wpa", value, strlen("wpa")))
                {
                    if (0 == strncmp("wpa-mixed", value, strlen("wpa-mixed")))
                    {
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "wpa-mixed");
                        p = value+strlen("wpa-mixed");
                    }
                    else if (0 == strncmp("wpa+wpa2", value, strlen("wpa+wpa2")))
                    {
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "wpa-mixed");
                        p = value+strlen("wpa+wpa2");
                    }
                    else if (0 == strncmp("wpa2", value, strlen("wpa2")))
                    {
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "wpa2");
                        p = value+strlen("wpa2");
                    }
                    else if (0 == strncmp("wpa", value, strlen("wpa")))
                    {
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].authmode, "wpa");
                        p = value+strlen("wpa");
                    }

                    if (*p == '+' && *(p+1) != 0)
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].cipher, p+1);
                    else
                        STRNCPPP(wifi_cfg[cur_dev].vifs[cur_vif].cipher, "tkip+ccmp");
                }

            }

            /* key */


#endif

            wifi_cfg[cur_dev].vifnum++;
        }
    }
    return;
}


void hooker(FILE * fp, param * p, const char * devname)
{
    int N = 0;
    int i = 0;

    //printf("API: %s(%s)\n", __FUNCTION__, p->element);

    if (!uci_wireless || !uci_ctx)
    {
        printf("%s() uci context not ready!\n", __FUNCTION__);
        return;
    }

    for(N=0; N= MBSSID_MAX)
    {
        printf("%s() device (%s) not found!\n", __FUNCTION__, devname);
        return;
    }

    if(0 == strmatch(p->dat_key, "SSID?"))
    {
        i = atoi(p->dat_key+4)-1;
        if(i<0 || i >= MBSSID_MAX)
        {
            printf("%s() array index error, L%d\n", __FUNCTION__, __LINE__);
            return;
        }
        FPRINT(fp, p, "%s", wifi_cfg[N].vifs[i].ssid.value);
    }
    else if(0 == strcmp(p->dat_key, "BssidNum"))
    {
        FPRINT(fp, p, "%d", wifi_cfg[N].vifnum);
    }
    else if(0 == strcmp(p->dat_key, "EncrypType"))
    {
        for(i=0; i0) FPRINT(fp, p, ";");

            if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "none"))
                FPRINT(fp, p, "NONE");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "wep-open")
                     || 0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "wep-shared")
                     || 0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "8021x"))
                FPRINT(fp, p, "WEP");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].cipher.value, "ccmp"))
                FPRINT(fp, p, "AES");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].cipher.value, "tkip"))
                FPRINT(fp, p, "TKIP");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].cipher.value, "ccmp+tkip")
                     || 0 == strcasecmp(wifi_cfg[N].vifs[i].cipher.value, "tkip+ccmp"))
                FPRINT(fp, p, "TKIPAES");
            else
                FPRINT(fp, p, "NONE");
        }
    }
    else if(0 == strcmp(p->dat_key, "AuthMode"))
    {
        for(i=0; i0) FPRINT(fp, p, ";");

            if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "none"))
                FPRINT(fp, p, "OPEN");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "wep-open"))
                FPRINT(fp, p, "OPEN");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "8021x"))
                FPRINT(fp, p, "OPEN");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "wep-shared"))
                FPRINT(fp, p, "SHARED");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "wep-auto"))
                FPRINT(fp, p, "WEPAUTO");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "psk"))
                FPRINT(fp, p, "WPAPSK");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "psk2"))
                FPRINT(fp, p, "WPA2PSK");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "psk-mixed")
                     || 0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "psk+psk2"))
                FPRINT(fp, p, "WPAPSKWPA2PSK");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "wpa"))
                FPRINT(fp, p, "WPA");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "wpa2"))
                FPRINT(fp, p, "WPA2");
            else if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "wpa-mixed")
                     || 0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "wpa+wpa2"))
                FPRINT(fp, p, "WPA1WPA2");
            else
                FPRINT(fp, p, "OPEN");
        }

    }
    else if(0 == strcmp(p->dat_key, "HideSSID"))
    {
        for(i=0; i0) FPRINT(fp, p, ";");
            FPRINT(fp, p, wifi_cfg[N].vifs[i].hidden.value[0]=='1'?"1":"0");
        }
    }
    else if(0 == strcmp(p->dat_key, "Channel"))
    {
        if(0 == strcmp(p->value, "auto"))
            FPRINT(fp, p, "0");
        else
            FPRINT(fp, p, p->value);
    }
    else if(0 == strcmp(p->dat_key, "AutoChannelSelect"))
    {
        if(0 == strcmp(p->value, "0"))
            FPRINT(fp, p, "2");
        else
            FPRINT(fp, p, "0");
    }
    else if(0 == strcmp(p->dat_key, "HT_BW"))
    {
        if(0 == strcmp(p->value, "0"))
            FPRINT(fp, p, "0");
        else
            FPRINT(fp, p, "1");
    }
    else if(0 == strcmp(p->dat_key, "VHT_BW"))
    {
        if(0 == strcmp(p->value, "2"))
            FPRINT(fp, p, "1");
        else
            FPRINT(fp, p, "0");
    }
    else if(0 == strmatch(p->dat_key, "WPAPSK?"))//(0 == strncmp(p->dat_key, "WPAPSK", 6))
    {
        i = atoi(p->dat_key+6)-1;
        if(i<0 || i >= MBSSID_MAX)
        {
            printf("%s() array index error, L%d\n", __FUNCTION__, __LINE__);
            return;
        }
        if (0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "psk")
            || 0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "psk2")
            || 0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "psk+psk2")
            || 0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "psk-mixed"))
            FPRINT(fp, p, "%s", wifi_cfg[N].vifs[i].key.value);
    }
    else if(0 == strcmp(p->dat_key, "RADIUS_Server"))
    {
        for(i=0; i0) FPRINT(fp, p, ";");
            FPRINT(fp, p, "%s", wifi_cfg[N].vifs[i].auth_server.value);
        }
    }
    else if(0 == strcmp(p->dat_key, "RADIUS_Port"))
    {
        for(i=0; i0) FPRINT(fp, p, ";");
            FPRINT(fp, p, "%s", wifi_cfg[N].vifs[i].auth_port.value);
        }
    }
    else if(0 == strmatch(p->dat_key, "RADIUS_Key?"))//(0 == strncmp(p->dat_key, "WPAPSK", 6))
    {
        i = atoi(p->dat_key+10)-1;
        if(i<0 || i >= MBSSID_MAX)
        {
            printf("%s() array index error, L%d\n", __FUNCTION__, __LINE__);
            return;
        }
        FPRINT(fp, p, "%s", wifi_cfg[N].vifs[i].auth_secret.value);
    }
    else if(0 == strcmp(p->dat_key, "PreAuth"))
    {
        for(i=0; i0) FPRINT(fp, p, ";");
            FPRINT(fp, p, "%s", wifi_cfg[N].vifs[i].preauth.value);
        }
    }
    else if(0 == strcmp(p->dat_key, "RekeyInterval"))
    {
        for(i=0; i0) FPRINT(fp, p, ";");
            FPRINT(fp, p, "%s", wifi_cfg[N].vifs[i].rekeyinteval.value);
        }
    }
    else if(0 == strcmp(p->dat_key, "PMKCachePeriod"))
    {
        for(i=0; i0) FPRINT(fp, p, ";");
            FPRINT(fp, p, "%s", wifi_cfg[N].vifs[i].pmkcacheperiod.value);
        }
    }
    else if(0 == strcmp(p->dat_key, "RekeyMethod"))
    {
        FPRINT(fp, p, "%s", p->defvalue);
    }

    else if(0 == strcmp(p->dat_key, "IEEE8021X"))
    {
        for(i=0; i0) FPRINT(fp, p, ";");
            if(0 == strcasecmp(wifi_cfg[N].vifs[i].authmode.value, "8021x"))
                FPRINT(fp, p, "%s", "1");
        }
    }
    else if(0 == strmatch(p->dat_key, "DefaultKeyID"))  /* WEP */
    {
        for(i=0; idat_key, "Key?Type"))  /* WEP */
    {
        /* TODO: do we need to support byte sequence?  */
        FPRINT(fp, p, "%s", "0");
    }
#endif
    else if(0 == strmatch(p->dat_key, "Key?Type"))  /* WEP */
    {
    int j;
    i = atoi(p->dat_key+3)-1;
    for(j=0; jdat_key, "Key?Str?"))  /* WEP */
    {
        int j;
        i = atoi(p->dat_key+3)-1;
        j = atoi(p->dat_key+7)-1;
        if(0 == strncmp("s:", wifi_cfg[N].vifs[j].wepkey[i].value, 2))
            FPRINT(fp, p, "%s", wifi_cfg[N].vifs[j].wepkey[i].value+2);
        else
            FPRINT(fp, p, "%s", wifi_cfg[N].vifs[j].wepkey[i].value);
    }
#if 0
    else if(0 == strmatch(p->dat_key, "ApCliKey?Type"))  /* Ap Client Mode */
    {
        i = atoi(p->dat_key+8)-1;
        /* TODO */
    }
    else if(0 == strmatch(p->dat_key, "ApCliKey?Str"))  /* Ap Client Mode */
    {
        i = atoi(p->dat_key+8)-1;
        /* TODO */
    }
    else if(0 == strmatch(p->dat_key, "Wds?Key"))  /* Ap Client Mode */
    {
        i = atoi(p->dat_key+3)-1;
        /* TODO */
    }
    else if(0 == strmatch(p->dat_key, "RADIUS_Key?"))  /* Radius */
    {
        i = atoi(p->dat_key+10)-1;
        /* TODO */
    }
#endif
    /* the rest part is quite simple! */
    else
    {
        FPRINT(fp, p, p->value);
    }

}


void gen_dat(char * devname, char * datpath)
{
    FILE       * fp = NULL;
    char buffer[64] = {0};
    int           i = 0;
    param       * p = NULL;
    wifi_params * cfg = NULL;

    printf("API: %s(%s, %s)\n", __FUNCTION__, devname, datpath);

    for (i=0; idevname);
        system(buffer);

        snprintf(buffer, sizeof(buffer), "/etc/wireless/%s/%s.dat", cfg->devname, cfg->devname);
        // snprintf(buffer, sizeof(buffer), "/%s.dat", cfg->devname); //test only
        fp = fopen(buffer, "wb");
    }

    if(!fp)
    {
        printf("Failed to open %s, %s!\n", buffer, strerror(errno));
        return;
    }

    fprintf(fp, "# Generated by uci2dat\n");
    fprintf(fp, "# The word of \"Default\" must not be removed\n");
    fprintf(fp, "Default\n");


    for(i=0; iparams[i];
        printf("%s(), %s\n", __FUNCTION__, p->dat_key);
        fprintf(fp, "%s=", p->dat_key);
        if(p->hook)
            p->hook(fp, p, cfg->devname);
        else if(strlen(p->value) > 0)
            fprintf(fp, p->value);
        else if(p->defvalue)
            fprintf(fp, p->defvalue);
        fprintf(fp, "\n");
    }

    fclose(fp);

    return;
}

void init_wifi_cfg(void)
{
    struct uci_element *e   = NULL;
    int i,j;

    for(i=0; isections, e)
    {
        struct uci_section *s = uci_to_section(e);
        if(0 == strcmp(s->type, "wifi-device"))
        {
            for(i=0; ie.name, sizeof(wifi_cfg[i].devname));
                    break;
                }
            }

            if(i>=DEVNUM_MAX)
            {
                printf("%s(), too many devices!\n", __FUNCTION__);
                break;
            }
        }
    }
}

void usage(void)
{
    int i, j;
    param * p = NULL;

    printf("uci2dat  -- a tool to translate uci config (/etc/config/wireless)\n");
    printf("            into ralink driver dat.\n");
    printf("\nUsage:\n");
    printf("    uci2dat -d  -f \n");

    printf("\nArguments:\n");
    printf("    -d    device name, mt7620, eg.\n");
    printf("    -f    dat file path.\n");

    printf("\nSupported keywords:\n");
    printf("     %-16s\t%-16s\t%s\n", "[uci-key]", "[dat-key]", "[default]");
    for(i=0, j=0; iuci_key)
        {
            printf("%3d. %-16s\t%-16s\t%s\n",j, p->uci_key, p->dat_key, p->defvalue);
            j++;
        }
    }

    printf("%2d. %s\n", j++, VIF.ssid.uci_key);
    printf("%2d. %s\n", j++, VIF.authmode.uci_key);
    printf("%2d. %s\n", j++, VIF.hidden.uci_key);
    printf("%2d. %s\n", j++, VIF.cipher.uci_key);
    printf("%2d. %s\n", j++, VIF.key.uci_key);

}


int main(int argc, char ** argv)
{
    int opt = 0;
    char * dev = NULL;
    char * dat = NULL;
    char olddat[128] = {0};
    int test = 0;

    while ((opt = getopt (argc, argv, "htf:d:")) != -1)
    {
        switch (opt)
        {
            case 'f':
                dat = optarg;
                printf("---- datpath=\"%s\"\n", dat);
                break;
            case 'd':
                dev = optarg;
                printf("---- devname=\"%s\"\n", dev);
                break;
            case 't':
                test = 1;
                printf("---- TEST MODE ----\n");
                break;
            case 'h':
                usage();
                return OK;
            default:
                usage();
                return NG;
        }
    }

    if (!uci_ctx)
    {
        uci_ctx = uci_alloc_context();
    }
    else
    {
        uci_wireless = uci_lookup_package(uci_ctx, "wireless");
        if (uci_wireless)
            uci_unload(uci_ctx, uci_wireless);
    }

    if (uci_load(uci_ctx, "wireless", &uci_wireless))
    {
        return NG;
    }

#if 0
    uci_foreach_element(&uci_wireless->sections, e)
    {
        struct uci_section *s   = uci_to_section(e);
        struct uci_element *ee  = NULL;
        struct uci_option  *o   = NULL;

        printf("%s() === %s\n", __FUNCTION__, s->type);
        uci_foreach_element(&s->options, ee)
        {
            o = uci_to_option(ee);
            printf("%s() : <%s>=<%s>\n", __FUNCTION__, ee->name, o->v.string);
        }
    }
#endif

    init_wifi_cfg();

    if(dev && dat)
    {
        snprintf(olddat, sizeof(olddat), "/rom%s", dat);
        parse_dat(dev, olddat);
        parse_uci(NULL);
    }

    if(test)
    {
        FILE * fp = NULL;
        char * p = NULL;
        char device[32] = {0};
        char profile[64] = {0};
        fp = popen("cat /etc/config/wireless"
                   " | grep \"wifi-device\""
                   " | sed  -n \"s/config[ \t]*wifi-device[\t]*//gp\"",
                   "r");
        if(!fp)
        {
            printf("%s(), error L%d\n", __FUNCTION__, __LINE__);
            return NG;
        }
        while(fgets(device, sizeof(device), fp))
        {
            if (strlen(device) > 0)
            {
                p = device+strlen(device)-1;
                while(*p < ' ')
                {
                    *p=0;    // trim newline
                    p++;
                }
                snprintf(profile, sizeof(profile), "/etc/wireless/%s/%s.dat", device, device);
                parse_dat(device, profile);
            }
            else
                printf("%s(), error L%d\n", __FUNCTION__, __LINE__);
        }
        pclose(fp);
        parse_uci(NULL);
        __dump_all();

    }
    else if(dev && dat)
        gen_dat(dev, dat);
    else
        usage();

    uci_unload(uci_ctx, uci_wireless);
    return OK;
}

你可能感兴趣的:(mtk 的uci2dat工具)

  • 一点关于未来的微不足道的看法 酣眠初醒
    听了一位老师说过的话：当一个人足够优秀足够有能力的时候，钱会自动找上门昨夜，彻夜难眠，一直在思索这个问题，当然赚钱的基础更多的是看能力，运气成分占的是少数对于我现阶段来说，赚钱的话，可以能力有些不够，只能最多做些做基础的临时工，要不就是通过网络上一些小兼职赚一些外快可这些毕竟是副业，与自身专业背道而驰，对于我来说用自己的兴趣爱好来赚钱是几乎赚不到多少钱的再加上要想赚许多钱的话，就是创业，投资，可是
  • 只有一个诚字最重要（3.22） 胡同学的读书笔记
    1人们会认为谷歌是搜索引擎。而事实上，谷歌是第一个以机器为主导的搜索引擎，这个分类在谷歌之前是不存在的，而你必须要认识到谷歌的这个秘密才能判断它与其他公司的不同之处。2如果我目前在一个公司，当大家不知道未来的路怎么走，过去的路也已经彻底放弃了，我会先把事实摆在所有人面前，然后让大家讨论，在争论的过程中产生一个纲领性的共识，让每个部门在大的纲领下去寻求一种变化，不再以增长和竞争为纲，而是转移到产品和
  • 北京•HOLIC | 一杯坚持七年的芝麻酱拿铁 一朵云里
    ——醒开的老北京六必居麻酱打底，18g拖延症拼配豆浓缩，配上纯牛奶与芝麻糖，闻酱退三步的我，竟然一口不剩喝完了。HOLICCOFFEE藏在北京高楼林立的CBD中，它是全城‘起’得最早的一批咖啡馆。早上8点它就要开始迎接客人，这就意味着主理人要在7点前到店，并在一个小时内完成全部开业准备。芝麻酱饼拿铁主理人萌萌说，要是不与写字楼的生物钟同步，HOLIC早就被淘汰在一秒三十杯的循环里了。是的，写字楼咖
  • 致命友的一封信 童话2020522
    我亲爱的命友们，非常高兴以这种形式，和大家聊天，首先，我先在这里和大家说声抱歉，因为自建群以来，我在群里面只讲过一次课，然后从来也没做过自我介绍，因为你们是我的朋友，觉得我不用过多的说些什么，但是今天发现群里已经73人了。有好多人是通过朋友进来的，然后也有的是和我打个招呼，说我也想嗯，去进里面听一听我说可以呀，然后就进来了，所以大部人分可能还不太了解。我首先首先呢，我是个医生，在疫情期间，一直坚守
  • 可我们都曾是个孩子呀 左小祺
    有一天，我心血来潮，想选择一种佛性的方式度过一天，于是我选择了去香山公园摆摊卖书。我背着半书包书来到北京香山公园门口，然后在台阶上铺上报纸，把书拿出几本，就坐等着路过的人向我询问。本打算卖出一本书后就买张门票进公园的，可坐等了半小时也无人问津，终于在等得不耐烦的时候，一位阿姨过来疑惑地问：“你是在卖书？”我说：“是的，这是我自己写的，如果喜欢的话就买一本吧。”阿姨拿起书来翻看了一会，说：“你的书多
  • 自信 净域
    今天我打击了某人的自信我的自信回来了损有余而补不足不得不说我喜欢这个特殊的正能量不是会放大缩小而是类似熵平衡的那种奇怪的平衡
  • 藏着一个未曾绽放的梦 木子墨
    老槐树斑驳的树影下，是一把竹编的老旧椅子，不是很大，甚至对于大人们来说，像极了一把不大不小的凳子，往上一坐，一阵吱呀乱响。这是一段藏在记忆里的连锁片段，是一段有画面感的衍生物。秋风不曾来过，外头一直嘹亮的不止蝉鸣，有时，近处也有几只蝈蝈。喔，对了！这其实是孩子A的一个梦，看！那树下数星星的就是他。我不知道他数了多久，我刚来。就坐在墙头的一角看着，不打搅。这样的夜色，不知多久没看到了，深邃美丽。正想
  • 人生最好的状态：活得有度，活得有爱，活得有趣 雪轩_b08d
    年，就这样过完了。心，却依旧，像平静的湖面，无波无澜。不知道从什么时候开始，过年，不再是一种憧憬，而成为了一种形式。以往过年，缺的是年货，不缺年味；现在过年，不缺年货，缺的是年味！过去的年味再也找不回来了！难忘今宵，唱了一年又一年，再也找不回以前的那种激情，不变的是日出日落的一年四季，变了的是我们逐渐苍老的容颜！难以找到原来的模样。岁月，更是无情的雕刻在我们每个人的心上，岁月如梭，各位亲，且行且珍
  • 中原焦点团队网络初级23班 陈松 分享第45天 读书29天 悟_b6c1
    SFBT将赞美和重新建构和称为正向眼光。重新建构是SFBT的一个很重要的技巧与精神。重新建构指的是：我们基于事情不会只有一个面向，从不同看待事情的眼光，看到当事人的特质，优点，动机，努力引导他看见事情的其他方向，进而拓展当事人的思考，引发不同的行动。重新建构的另一个意义是：我们了解了孩子描述的事情并重新诠释后，赋予相同的事件不同不同区正向的意义，看到事件本身所带来的正面价值，进而形成新的解决方案或
  • 2021-07-06 君思我兮
    收到这封情书的时候，离我们成为法律意义上的夫妻还有一两个小时。此时是七月六日的十一点刚过。初稿既成，我们分坐在沙发上，父母各自忙，窗外的雨滴滴答答。没有想到这个安静的夜晚我会想这么多，一生太短，一生也很漫长。云消雨霁，汉江河水又会上涨，浮浮沉沉，像是我们跌跌荡荡的一生。我们曾经到访过汉江源头，那里清晰标注着汉江水系的脉络。汉江干流发源于陕西宁强县的嶓冢山，自西而东浩浩荡荡，于白河县进入湖北省。宁强
  • 徐忠顺刘友龙秦皇岛焦点解决坚持分享第66天2020.04.07 雨顺心理
    助人者SFBT技术，不单纯是一个心理学技术，更是每个人生活哲学的重要组成部分。以往，看到“助人者”时，总是想到的是“咨询师”。而从生活哲学层面看“助人者”是一种广义的称呼，凡是在生活中可能提供他人协助的人都可以称为“助人者”，包括父母、教师、主管、督导、咨询师、社工人员、神职人员、义务助人工作者等；家人、同事、朋友之间，也可能互相帮助。
  • 一切皆是映射：AI的去中心化：区块链技术的融合 AI大模型应用之禅 计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
    一切皆是映射：AI的去中心化：区块链技术的融合作者：禅与计算机程序设计艺术/ZenandtheArtofComputerProgramming关键词：AI，区块链，去中心化，智能合约，共识机制，数据安全，隐私保护，分布式账本技术，机器学习，数据隐私1.背景介绍1.1问题的由来随着人工智能（AI）技术的快速发展，其在各个领域的应用越来越广泛，从自动驾驶、智能医疗到金融服务，AI正在改变着我们的生活。
  • VLSI 电路单元的自动布局-2024华数杯B题 2401_84314384 算法python数学建模
    摘要超大规模集成电路设计通常采用电子设计自动化(EDA)的方式进行，布局是EDA工具的核心的核心。本文通过构建的线长评估模型及网格密度评估模型，并在此基础上对模型进行优化，最后利用模型实现VLSI电路单元的自动布局。问题一：基于结合直线型斯坦纳最小树思想的优化HPWL模型评估与电路单元连线接口坐标相关的线长。本题需要建立与电路单元连线接口坐标相关的线长评估模型，最小化每组估计线长与对应RSMT的差
  • 阿里云新用户账号看不到2核2G49.68元1年的云服务器是怎么回事？ 阿里云最新优惠和活动汇总
    阿里云2022年的双11大促活动“金秋云创季”活动正在火热进行中，但是有部分用户明明看到活动中有说明，此次双11活动有2核2G49.68元1年、2核4G100元1年的云服务器，但是自己的账号虽然还未购买过阿里云产品，应该算是新账号，但是看到的价格却要远远高于这个价格，那么阿里云新用户账号看不到2核2G49.68元1年的云服务器是怎么回事呢？下面小编为大家做个分析，你就知道原因了。为什么我们账号看不
  • 有点困 有柳盈屋
    2021.6.24，周四早晨4：55就醒来了，索性早点起床，测量完血压，早点出去锻炼。直接完成万步有约。收拾停当，未参加机关学习，直接开车去县委五楼小会议室参加护航党的百年华诞维护政治安全专项会议，姚芳青主持，王伟刚传达中央省市委宣传部有关会议精神，许树峰讲话。会后开车去红旗超市购小花生米大黑豆绿豆35，门口设计太low，小小停车场就是个摆设，新开路中间还设了隔离带，完全的毫无人性，十分不方便。临
  • 言情小说《相亲领证后，豪门老公抢着帮我虐渣》沈均衡顾柠（全文免费阅读） 九月文楼
    言情小说《相亲领证后，豪门老公抢着帮我虐渣》沈均衡顾柠（全文免费阅读）主角：沈均衡顾柠简介：为了反抗家中的联姻，顾柠随便找了个人闪婚。却不曾想，被大家各种瞧不起的，即将濒临破产的老公，竟然是丰城首富！关注微信公众号【海边书楼】去回个书号【83】，即可阅读【相亲领证后，豪门老公抢着帮我虐渣】小说全文！“沈钧衡，你跑哪儿去了？还有，你怎么放着自己那辆玛莎拉帝不开，把我的小奔开走了？”沈钧衡扫了一眼副驾
  • 奇迹分享8月17日 一切的力量都在爱里
    感恩真我的穿越，从混乱中瞬间回到和平的感觉，这个体验让我更加确切地我只想要和平，它是弥足珍贵的.我只要和平，谨记今天，信守承诺.图片发自App
  • 收获50日徽章，辛苦与幸福并存 露娜2005
    昨天收获了50天日更徽章，在这期间发布了60篇文章，8.9万字，收获1580个喜欢，1000+粉丝。回顾这段日子，就是每天自己跟宝宝争分夺秒抢时间较劲的50天，所以才会感觉特别辛苦，但是每次完成自己还算比较满意的文章，而且能收获友友们的点评与认可，心中就会有升起满满的幸福感。每天一小步，成功一大步加入的初衷就是为了写作而来，而写作最重要的品质就是持之以恒。做事是否快捷，不在一时奋发，而在能否持久。
  • 2024年最新Python面试简历模板，Python下载中国数据库大会（DTCC2024）PPT全集(3)，字节跳动面试难吗 2401_84123188 2024年程序员学习python面试数据库
    收集整理了一份《2024年最新Python全套学习资料》免费送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来如果你需要这些资料，可以添加V无偿获取：hxbc188（备注666）正文frombs4im
  • 2019-03-05 xiaosine
    从事材料、化学等相关专业和领域的科研人员，工作者，其工艺流程图、化学式的绘制是少不了的，通常绘制于白色背景下，简洁，但太过于单调。放在科研文章中，难以凸显重点，放在汇报的PPT上，不符主题风格。那如何绘制出下图所示的结构式及流程图在不同背景下所衬托出的效果呢。图一结构式及流程图在不同背景下衬托出的效果可能有人会通过完成构图的两张图片用PS的图层叠加功能来实现，但通过PS处理后会发现整体颜色失真，部
  • 绘画分析打卡90天---24天 生活从改变开始
    图片发自App【画者的基本信息】画者是一位36岁男性一【画面整体】（包括画面的大小、位置线条、颜色等）画面大小---画面大于4/5，自我为中心画面位置---中间，家庭环境整体状况比较健康正常，未受父母过多影响。画面线条---用笔的力重，自信。线条流畅，长线条和直线条居多，自我控制力强，对行动控制得体。有关男性化，自信，攻击性，固执，待人处事可素性差。【基本特征及释义】（包括房子、树木、人物及附属物
  • 《比宇宙更远的地方》漫评 灯塔文创
    图片发自App你是否为了你的梦想而奋不顾身《比宇宙更远的地方》讲述的就是这样一个故事，故事发生在日本，主角是一个名叫真理普普通通的女高中生，上了高中之后觉得自己长大了，想要做一些与过去不一样的事，却又无法下定决心，直到后来一次偶然机遇碰到了一心想去南极的报濑，便决定和她同行，后来又遇到了早早辍学的成熟的日向，以及身为偶像却对友谊无比执念的少女结月，就这样，最终四个少女完成了跟随科考队一起前往南极的
  • ubuntu美化 BGLB
    先来美化完成的几张图诱惑一下主要做一下记录系统环境：1、ubuntu18.042、VMware143、美化需要的主题和icon百度云自取链接：https://pan.baidu.com/s/1Om8ntCJHm7341a0ZC-emiQ提取码：4axn正式开始美化建议直接使用root登陆ubuntu系统方便第一步首先要先安装相应的工具：TweakTool中文名叫优化英文名叫gnome-tweak-
  • “坑娃”“坑娘”母婴用品大盘点，来看看你中招了没 项项_b23d
    每个父母都希望，在自己能力范围内，给孩子提供最好的，在有了宝宝以后，免不了各种买买买。都说女人和孩子的钱好赚，所以现在市面上母婴用品层出不穷，各位宝妈在“剁手”前，一定要悠着点，很多母婴用品，是“坑娘”又“坑娃”呀。今天就为大家整理一下这些母婴用品的坑：1、高景观车高景观车看着豪华上档次，一般价格也很上档次，但是买回去你就会发现各种被坑，非常笨重，每次出门都是一次体力活，家里没个大型SUV,后备箱
  • Android MVVM 架构应用实现(2) 渊Y 程序员android架构
    Repository类：实现BmobRepository类，作为HomeViewModel的数据提供方。BmobRepository类中有一个挂起函数getAllRecommendLibrary(libraryRecommendData:MutableLiveData)用来获取云数据库中的数据，函数的参数是LiveData，在获取数据后，利用setValue通知View展示数据。classBmob
  • 程序修改题（11-20） 2401_82772407 计算机二级C语言c语言算法开发语言c++笔记经验分享
    第十一题题目给定程序MODI1.C中，函数fun的功能是:找出n的所有因子，统计因子的个数，并判断n是否是”完数”。当一个数的因子之和恰好等于这个数本身时，就称这个数为”完数”。例如:6的因子包括1、2、3，而6=1+2+3，所以6是完数。如果是完数，函数返回值为1，否则函数返回值为0。数组a中存放的是找到的因子，变量k中存放的是因子的个数。#includeintfun(intn,inta[],i
  • Python——俄罗斯方块 星和月 pythonpygame开发语言
    俄罗斯方块游戏是一款经典的益智游戏，通常使用编程语言Python来实现。下面是一个简单的俄罗斯方块游戏的示例代码：importpygameimportrandom#定义颜色BLACK=(0,0,0)WHITE=(255,255,255)RED=(255,0,0)GREEN=(0,255,0)BLUE=(0,0,255)CYAN=(0,255,255)MAGENTA=(255,0,255)YELLO
  • Python——爬虫 星和月 python
    当编写一个Python爬虫时，你可以使用BeautifulSoup库来解析网页内容，使用requests库来获取网页的HTML代码。下面是一个简单的示例，演示了如何获取并解析网页内容：importrequestsfrombs4importBeautifulSoup#发送HTTP请求获取网页内容url='https://www.example.com'#要爬取的网页的URLresponse=requ
  • 惨痛！沈阳公交车突然撞向站台 致1死九伤 司机说不清原因 拾忆Memories
    7月2日下午一点左右，沈阳一辆126路公交车在没有减速的情况下，直接冲向公交车站，在撞上路边石栏后，又撞上路边的电线杆。其实，一名20岁左右的年轻女子不幸被撞倒，夹在了车底和电线杆之间，后证实不治。其他候车市民及车内乘客共9人受伤（伤者已无生命危险），伤者都已被救护车送往医院。事发后，现场一片混乱，肇事公交车损毁严重，车头挡风玻璃几乎完全碎裂，被撞坏的护栏和公交车站牌的碎片散落一地。但发生这么严重
  • 26丨不安全依恋：爱为什么会变成牢笼？ 满塘荷叶一枝莲
    既然自我不再是稳固的实体，而是关系的产物，那么自我发展的核心问题，也就从一个孤立的个体如何创造新经验，转变成了一个身处关系中的人如何构建有利于自我发展的新关系。那么，什么样的关系最有利于自我的发展？我心里的答案是：一种自主的、有选择的，但又能够为自己负责的关系。这样的关系有两个特征：首先，我们不会轻易被别人的情绪影响，而是能自由地做出选择。其次，我们能够去不断探索新的关系，发现更多新的自己，而不是
  • 辗转相处求最大公约数 沐刃青蛟 C++漏洞
    无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！   为此，总结一下以方便日后忘了好查找。   1.输入要比较的两个数a,b   忽略：2.比较大小（因为后面要的是大的数对小的数做%操作）   3.辗转相除（用循环不停的取余，如a%b,直至b=0）   4.最后的a为两数的最大公约数 &
  • F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5负载均衡
    一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
  • Object.equals方法：重载还是覆盖 Cwind javagenericsoverrideoverload
    本文译自StackOverflow上对此问题的讨论。 原问题链接   在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
  • 初始线程 15700786134
          暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。            既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
  • Linux的tcpdump 被触发 tcpdump
    用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。 实用命令实例 默认启动 tcpdump 普通情况下，直
  • 安卓程序listview优化后还是卡顿 肆无忌惮_ ListView
    最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
  • 扩展easyUI tab控件，添加加载遮罩效果 知了ing jquery
    (function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
  • gradle上传jar到nexus 矮蛋蛋 gradle
    原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations {     deployerJars } dependencies {     deployerJars "org.apache.maven.wagon
  • 千万条数据外网导入数据库的解决方案。 alleni123 sqlmysql
    从某网上爬了数千万的数据，存在文本中。 然后要导入mysql数据库。 悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。 于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
  • JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作 字符流
    这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流   字节流和字符的难点：a,怎么将读到的数据
  • MO、MT解读 bijian1013 GSM
    MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息； 上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
  • 五个JavaScript基础问题 bijian1013 JavaScriptcallapplythisHoisting
    下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。 问题1：Scope作用范围 考虑下面的代码：  (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？  回答：         上面的代码会打印 5。 &nbs
  • 【Thrift二】Thrift Hello World bit1129 Hello world
    本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程   1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
  • 【Avro一】Avro入门 bit1129 入门
    本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。   1. 添加Maven依赖   <?xml version="1.0" encoding="UTF-8"?> <proj
  • 安装nginx+ngx_lua支持WAF防护功能 ronin47
    需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
  • java-5.查找最小的K个元素-使用最大堆 bylijinnan java
    import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
  • TCP的TIME-WAIT bylijinnan socket
    原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记 说明： 主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
  • jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
       checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值   <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
  • Apache集群乱码和最高并发控制 cuisuqiang apachetomcat并发集群乱码
    都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。 最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
  • websocket dalan_123 websocket
    一、低延迟的客户端-服务器 和 服务器-客户端的连接 很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。   通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
  • 菜鸟分析网络执法官 dcj3sjt126com 网络
      最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
  • Android相对布局属性全集 dcj3sjt126com android
    RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
  • Tomcat内存设置详解 eksliang jvmtomcattomcat内存设置
    Java内存溢出详解   一、常见的Java内存溢出有以下三种：   1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。 可以利用JVM提
  • Java6 JVM参数选项 greatwqs javaHotSpotjvmjvm参数JVM Options
    Java 6 JVM参数选项大全（中文版）   作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！   本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
  • weblogic创建JMC i5land weblogicjms
    进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
  • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
    上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。 系统包括几个独立的部分： 使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子； 使用 PHP CI 框架开发的简易网站； 搜索引擎目前直接使用的 MySQL，将来可以考虑使
  • sql添加、删除表中的列 macroli sql
    添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
  • PHP中二维数组的排序方法 abc123456789cba 排序二维数组PHP
    <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
  • hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hivehive优化
    一、    控制hive任务中的map数: 1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。 主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
  • Spring Boot 1.2.4 发布 wiselyman spring boot
    Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。   这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。   Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他