static int
strcollsp(CHARSET_INFO *cs, const STRNNCOLL_PARAM *param)
{
int failed= 0;
const STRNNCOLL_PARAM *p;
diag("%-20s %-10s %-10s %10s %10s", "Collation", "a", "b", "ExpectSign", "Actual");
for (p= param; p->a; p++)
{
char ahex[64], bhex[64];
int res= cs->coll->strnncollsp(cs, (uchar *) p->a, p->alen,
(uchar *) p->b, p->blen, 0);
str2hex(ahex, sizeof(ahex), p->a, p->alen);
str2hex(bhex, sizeof(bhex), p->b, p->blen);
diag("%-20s %-10s %-10s %10d %10d%s",
cs->name, ahex, bhex, p->res, res,
eqres(res, p->res) ? "" : " FAILED");
if (!eqres(res, p->res))
{
failed++;
}
else
{
/* Test in reverse order */
res= cs->coll->strnncollsp(cs, (uchar *) p->b, p->blen,
(uchar *) p->a, p->alen, 0);
if (!eqres(res, -p->res))
{
diag("Comparison in reverse order failed. Expected %d, got %d",
-p->res, res);
failed++;
}
}
}
return failed;
}
/*******************************************************************************
* Function Name : CanHexProg request, server
* Description : dekodira in razbije vrstice hex fila na pakete 8 bytov in jih
* : pošlje na CAN bootloader
* Input : pointer na string, zaporedne vrstice hex fila, <cr> <lf> ali <null> niso nujni
* Output :
* Return : 0 ce je checksum error sicer eof(-1). bootloader asinhrono odgovarja z ACK message
* : za vsakih 8 bytov !!!
*******************************************************************************/
int CanHexProg(char *p) {
static int ExtAddr=0;
int n,a,i=FLASH_COMPLETE;
CanTxMsg TxMessage;
int *d=(int *)TxMessage.Data;
if(!p)
p=_Iap_string;
if(HexChecksumError(p))
return(0);
TxMessage.RTR=CAN_RTR_DATA;
TxMessage.IDE=CAN_ID_STD;
n=str2hex(&p,2);
a=(ExtAddr<<16)+str2hex(&p,4);
switch(str2hex(&p,2)) {
case 00:
TxMessage.StdId=_ID_IAP_ADDRESS;
d[0]=a;
TxMessage.DLC=sizeof(int);
if(p==_Iap_string)
PollCAN((CanRxMsg *)&TxMessage);
else
while(CAN_Transmit(CAN1,&TxMessage)==CAN_NO_MB);
TxMessage.StdId=_ID_IAP_DWORD;
for(i=0; n--;) {
TxMessage.Data[i++]=str2hex(&p,2);
if(i==8 || !n) {
TxMessage.DLC=i;
i=0;
if(p==_Iap_string)
PollCAN((CanRxMsg *)&TxMessage);
else
while(CAN_Transmit(CAN1,&TxMessage)==CAN_NO_MB);
}
}
break;
case 01:
break;
case 02:
break;
case 04:
case 05:
ExtAddr=str2hex(&p,4);
break;
}
return(EOF);
}
/*
* Choose root and swap devices.
*/
void
cpu_rootconf(void)
{
struct prom_n2f *nf;
const char *devname;
findfunc_t find;
char promname[4];
char partname[4];
const char *prompath;
int prom_ctlr, prom_unit, prom_part;
/* Get the PROM boot path and take it apart. */
prompath = prom_getbootpath();
if (prompath == NULL)
prompath = "zz(0,0,0)";
promname[0] = *(prompath++);
promname[1] = *(prompath++);
promname[2] = '\0';
prom_ctlr = prom_unit = prom_part = 0;
if (*prompath == '(' &&
*(prompath = str2hex(++prompath, &prom_ctlr)) == ',' &&
*(prompath = str2hex(++prompath, &prom_unit)) == ',')
(void)str2hex(++prompath, &prom_part);
/* Default to "unknown" */
booted_device = NULL;
booted_partition = 0;
devname = "<unknown>";
partname[0] = '\0';
find = NULL;
/* Do we know anything about the PROM boot device? */
for (nf = prom_dev_table; nf->func; nf++)
if (!strcmp(nf->name, promname)) {
find = nf->func;
break;
}
if (find)
booted_device = (*find)(promname, prom_ctlr, prom_unit);
if (booted_device) {
devname = device_xname(booted_device);
if (device_class(booted_device) == DV_DISK) {
booted_partition = prom_part & 7;
partname[0] = 'a' + booted_partition;
partname[1] = '\0';
}
}
printf("boot device: %s%s\n", devname, partname);
rootconf();
}
static int verify_sas(struct re_printf *pf, void *arg)
{
const struct cmd_arg *carg = arg;
(void)pf;
if (str_isset(carg->prm)) {
char rzid[ZRTP_STRING16] = "";
zrtp_status_t s;
zrtp_string16_t remote_zid = ZSTR_INIT_EMPTY(remote_zid);
if (str_len(carg->prm) != 24) {
warning("zrtp: invalid remote ZID (%s)\n", carg->prm);
return EINVAL;
}
(void) str2hex(carg->prm, (int) str_len(carg->prm),
rzid, sizeof(rzid));
zrtp_zstrncpyc(ZSTR_GV(remote_zid), (const char*)rzid,
sizeof(zrtp_zid_t));
s = zrtp_cache_set_verified(zrtp_global->cache,
ZSTR_GV(remote_zid),
true);
if (s == zrtp_status_ok)
info("zrtp: SAS for peer %s verified\n", carg->prm);
else {
warning("zrtp: zrtp_cache_set_verified"
" failed (status = %d)\n", s);
return EINVAL;
}
}
return 0;
}
zrtp_status_t zrtp_signaling_hash_set( zrtp_stream_t* ctx,
const char *hash_buff,
uint32_t hash_buff_length)
{
if (!ctx || !hash_buff) {
return zrtp_status_bad_param;
}
if (ZRTP_SIGN_ZRTP_HASH_LENGTH > hash_buff_length) {
return zrtp_status_buffer_size;
}
if (ctx->state != ZRTP_STATE_ACTIVE) {
return zrtp_status_wrong_state;
}
str2hex(hash_buff,
ZRTP_SIGN_ZRTP_HASH_LENGTH,
ctx->messages.signaling_hash.buffer,
ctx->messages.signaling_hash.max_length);
ctx->messages.signaling_hash.length = ZRTP_MESSAGE_HASH_SIZE;
ZRTP_LOG(3, (_ZTU_,"SIGNALLING HAS was ADDED for the comparison. ID=%u\n", ctx->id));
ZRTP_LOG(3, (_ZTU_,"Hash=%.*s.\n", ZRTP_SIGN_ZRTP_HASH_LENGTH, hash_buff));
return zrtp_status_ok;
}
int parse_web_data(const char* s_data,logo_recv_webclient_t *d_data)
{
char upload_s_tmp[256]={0};
char d_tmp[256]={0};
uint32_t j =0;
int s_len = strlen(s_data);
str2hex(s_data,s_len,upload_s_tmp);
upload_s_tmp[s_len/2] = '\0';
des_decrypt_n(KEY,upload_s_tmp,d_tmp,s_len/16);
UNPKG_H_UINT32(d_tmp,d_data->userid,j);
UNPKG_H_UINT32(d_tmp,d_data->channel,j);
UNPKG_H_UINT32(d_tmp,d_data->ip,j);
UNPKG_H_UINT32(d_tmp,d_data->time,j);
UNPKG_H_UINT32(d_tmp,d_data->width_limit,j);
UNPKG_H_UINT32(d_tmp,d_data->height_limit,j);
UNPKG_H_UINT32(d_tmp,d_data->cnt,j);
CGI_DEBUG_LOG("UPLOAD_LOGO RECV WEB[%u %u %u %u %u %u %u]",d_data->userid,d_data->channel,d_data->ip,d_data->time,d_data->width_limit,d_data->height_limit,d_data->cnt);
for(uint32_t i=0;i < d_data->cnt && i < CNT_MAX;i++){
UNPKG_H_UINT32(d_tmp,d_data->thumb_arg[i].W,j);
UNPKG_H_UINT32(d_tmp,d_data->thumb_arg[i].H,j);
UNPKG_H_UINT32(d_tmp,d_data->thumb_arg[i].start_x,j);
UNPKG_H_UINT32(d_tmp,d_data->thumb_arg[i].start_y,j);
UNPKG_H_UINT32(d_tmp,d_data->thumb_arg[i].thumb_x,j);
UNPKG_H_UINT32(d_tmp,d_data->thumb_arg[i].thumb_y,j);
CGI_DEBUG_LOG("UPLOAD_LOGO RECV WEB[%u %u %u %u %u %u]",d_data->thumb_arg[i].W,
d_data->thumb_arg[i].H,
d_data->thumb_arg[i].start_x,
d_data->thumb_arg[i].start_y,
d_data->thumb_arg[i].thumb_x,
d_data->thumb_arg[i].thumb_y);
}
return SUCC;
}
int Cregact::verify_active_code (uint32_t user_id, char *active_code)
{
STRU_ACTIVE_KEY ak;
char buf1[sizeof (STRU_ACTIVE_KEY)];
str2hex (active_code, 2*sizeof (buf1), buf1);
//_DES_n (ACT_KEY, buf1, (char *)&ak, sizeof (buf1)/8);
des_decrypt_n(ACT_KEY, buf1, (char *)&ak, sizeof (buf1)/8);
//verify here
if (ak.user_id != user_id) {
#ifdef INNER_DEBUG
LOG (7, "user id error [%u] [%u]", ak.user_id, user_id);
#endif
return (-1);
}
if (time (NULL) - ak.now > TIME_SEP_WEEK) {
#ifdef INNER_DEBUG
LOG (7, "time is over [%u] [%u]", ak.now, time(NULL));
#endif
return (-1);
}
if ((ak.pri_key1 != FILLKEY1) || (ak.pri_key2 != FILLKEY2) || (ak.pri_key3 != FILLKEY3)) {
#ifdef INNER_DEBUG
LOG (7, "fill key is error");
#endif
return (-1);
}
return (0);
}
zrtp_status_t zrtp_signaling_hash_set( zrtp_stream_t* ctx,
const char *hash_buff,
uint32_t hash_buff_length)
{
if (!ctx) {
return zrtp_status_bad_param;
}
if (ZRTP_MESSAGE_HASH_SIZE*2 < hash_buff_length) {
return zrtp_status_buffer_size;
}
if (ctx->state != ZRTP_STATE_ACTIVE) {
return zrtp_status_wrong_state;
}
str2hex( hash_buff,
hash_buff_length,
ctx->messages.signaling_hash.buffer,
ctx->messages.signaling_hash.max_length);
ctx->messages.signaling_hash.length = ZRTP_MESSAGE_HASH_SIZE;
{
char buff[64];
ZRTP_LOG(3, (_ZTU_,"SIGNALLING HAS was ADDED for the comparision. ID=%u\n", ctx->id));
ZRTP_LOG(3, (_ZTU_,"Hash=%s.\n", hex2str(hash_buff, hash_buff_length, buff, sizeof(buff))));
}
return zrtp_status_ok;
}
/* DUAL mode, uap start at system initilize state. */
static void dual_uap_start(void)
{
sys_config_t *pconfig = get_running_config();
base_config_t *pbase = &pconfig->base;
extra_config_t *pextra = &pconfig->extra;
sys_unconfig_t *punconfig = get_un_config();
struct wlan_network wlan_config;
if (pbase->wifi_mode != DUAL_MODE)
return;
memset(&wlan_config, 0, sizeof(wlan_config));
/* Set profile name */
strcpy(wlan_config.name, "UAP");
strcpy(wlan_config.ssid, pextra->uap_ssid);
wlan_config.channel = 0;
wlan_config.mode = WLAN_MODE_UAP;
switch(pextra->uap_secmode) {
case SEC_MODE_WEP:
case SEC_MODE_WEP_HEX:
wlan_config.security.type = WLAN_SECURITY_WEP_OPEN;
break;
case SEC_MODE_WPA_NONE:
wlan_config.security.type = WLAN_SECURITY_NONE;
break;
case SEC_MODE_WPA_PSK:
wlan_config.security.type = WLAN_SECURITY_WPA2;
break;
default:
wlan_config.security.type = WLAN_SECURITY_WPA2;
break;
}
if (SEC_MODE_WEP_HEX == pextra->uap_secmode) {
wlan_config.security.psk_len = str2hex(pextra->uap_key,
wlan_config.security.psk, 32);
} else {
strcpy(wlan_config.security.psk, pextra->uap_key);
wlan_config.security.psk_len = strlen(pextra->uap_key);
}
if (punconfig->pmk_invalid[0] == 0) {
wlan_config.security.pmk_valid = 1;
memcpy(wlan_config.security.pmk, punconfig->pmk[0], WLAN_PMK_LENGTH);
}
wlan_config.address.addr_type = ADDR_TYPE_STATIC;
wlan_config.address.ip = 0x0a0a0a01;
wlan_config.address.gw = 0x0a0a0a02;
wlan_config.address.netmask = 0xffffff00;
wlan_config.address.dns1 = 0x0a0a0a01;
wlan_add_network(&wlan_config);
wlan_start_network(wlan_config.name);
}
/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO*/
void get_usr_pwds(char *subkey,char *usr)
{
long res;
HKEY hPwdKey;
char username[MAXSIZE]="";
char passwdhash[MAXSIZE*2]="", passwd[MAXSIZE]="",clearpasswd[MAXSIZE]="";
char fullname[MAXSIZE]="";
char email[MAXSIZE]="";
DWORD lType;
DWORD passwdhashsz=sizeof(passwdhash)-1,fullnamesz=MAXSIZE-1,emailsz=MAXSIZE-1;
res = RegOpenKeyEx(HKEY_LOCAL_MACHINE,subkey,0,KEY_ALL_ACCESS,&hPwdKey);
if(res!=ERROR_SUCCESS)
{
printf(" Error opening key %s! Error #:%d\n",subkey,res);
exit(1);
//return;
}
if(RegQueryValueEx(hPwdKey,"Password",0,&lType,(LPBYTE)passwdhash,&passwdhashsz)!= ERROR_SUCCESS)
{
RegCloseKey(hPwdKey);
return;
}
if(RegQueryValueEx(hPwdKey,"FullName",0,&lType,(LPBYTE)fullname,&fullnamesz)!= ERROR_SUCCESS)
{
RegCloseKey(hPwdKey);
return;
}
if(RegQueryValueEx(hPwdKey,"MailAddr",0,&lType,(LPBYTE)email,&emailsz)!=ERROR_SUCCESS)
{
RegCloseKey(hPwdKey);
return;
}
str2smallcase(usr);
strncpy(username,usr,sizeof(username)-1);
str2hex(passwdhash,passwd);
// adik 1234567
// adik 12
if(strlen(passwd)>strlen(username))
populate(username,strlen(passwd));
imail_decrypt(username,passwd,clearpasswd);
printf( "------------------------------------------------------------------------\n"
" FullName:\t %s\n"
" Email:\t\t %s\n"
" Username:\t %s\n"
" Password:\t %s\n",
fullname,email,usr,clearpasswd);
total_accs++;
RegCloseKey(hPwdKey);
}
static unsigned long
str_to_native_ulong(const char *str)
{
unsigned long x = 0, i = 0;
while ( *str && (i < BYTES_PER_LONG) )
{
#ifdef __BIG_ENDIAN
x <<= 8;
x += str2hex(str);
#elif defined(__LITTLE_ENDIAN)
x += (unsigned long)str2hex(str) << (i*8);
#else
# error unknown endian
#endif
str += 2;
i++;
}
return x;
}
/*******************************************************************************
* Function Name : CanHexProg request, server
* Description : dekodira in razbije vrstice hex fila na pakete 8 bytov in jih
* : pošlje na CAN bootloader
* Input : pointer na string, zaporedne vrstice hex fila, <cr> <lf> ali <null> niso nujni
* Output :
* Return : 0 ce je checksum error sicer eof(-1). bootloader asinhrono odgovarja z ACK message
* : za vsakih 8 bytov !!!
*******************************************************************************/
int HexrecOk(char *filename, FIL *f) {
int xa=0,a,amax=0,amin=INT_MAX;
char *p,s[64];
if(f_open(f,filename,FA_READ)==FR_OK) {
while(!f_eof(f)) {
p=s;
f_gets(p,64,f);
if(*p != ':') {
f_close(f);
return 0;
}
if(HexChecksumError(++p)) {
f_close(f);
return 0;
}
a=(xa<<16)+str2hex(&p,4)+str2hex(&p,2); // set address
switch(str2hex(&p,2)) {
case 00: // data record
if(a<amin)
amin=a;
if(a>amax)
amax=a;
break;
case 04:
xa=str2hex(&p,4);
break;
default:
break;
}
}
if(amin == (int)__Vectors) {
f_close(f);
return 0;
}
f_lseek(f,0);
return amin;
}
return NULL;
}
/*******************************************************************************
* Function Name : CanHexProg request, server
* Description : dekodira in razbije vrstice hex fila na pakete 8 bytov in jih
* : pošlje na CAN bootloader
* Input : pointer na string, zaporedne vrstice hex fila, <cr> <lf> ali <null> niso nujni
* Output :
* Return : 0 ce je checksum error sicer eof(-1). bootloader asinhrono odgovarja z ACK message
* : za vsakih 8 bytov !!!
*******************************************************************************/
int HexrecProg(char *p) {
int xa=0,amax=0,amin=INT_MAX;
int i,a,n;
union {
int i;
char c[4];
} d;
++p;
n=str2hex(&p,2); // number of bytes
a=(xa<<16)+str2hex(&p,4); // set address
switch(str2hex(&p,2)) {
case 00: // data record
for(i=0; n--;) {
if(!i)
d.i=*(int *)a; // get the programmed int value
d.c[i++]=str2hex(&p,2);
if(i==4 || !n) {
if(FlashProgram32(a,d.i))
return 0;
i=0;
a+=sizeof(int);
}
}
if(a<amin)
amin=a;
if(a>amax)
amax=a;
break;
case 04:
xa=str2hex(&p,4);
break;
}
return(amin);
}
int main(int argc, char* argv[])
{
if(argc < 2)
{
printf("Usage: secp256r1mult K\n");
exit(-1);
}
str2hex((void*)sk, argv[1], strlen(argv[1]));
ecc_ec_mult(ecc_g_point_x, ecc_g_point_y, sk, pkx, pky);
//Print256(sk);
fieldModO(pkx, pkx, 8);
//Print256((unsigned char *)pkx);
Print256_nbo((unsigned char *)pkx);
printf("\n");
return 0;
}
/*OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO*/
void decrypt_usr_pass(char *usr,char *passwd)
{
char username[MAX_NUM]="";
char passwordhash[MAX_NUM]="";
char outputbuff[250]="";
str2smallcase(usr);
strncpy(username,usr,sizeof(username)-1);
str2hex(passwd,passwordhash);
printf("------------------------------------------------------------------------\n");
printf( " Username:\t\t %s\n"
" Passwordhash:\t\t %s\n",usr,passwd);
if(strlen(passwordhash)>strlen(username))
populate(username,strlen(passwordhash));
imail_decrypt(username,passwordhash,outputbuff);
printf(" Decrypted passwd:\t %s\n",outputbuff);
printf("------------------------------------------------------------------------\n");
}
/* Write hash list to session file */
hash_stat session_write_hashlist(FILE *sessionfile)
{
#ifdef HAVE_JSON_JSON_H
json_object *jobj;
json_object *jchild;
struct hash_list_s *mylist;
char buff[1024];
if (get_cracked_num()==get_hashes_num()) return(hash_ok);
if (get_hashes_num()>100000)
{
hash_list_node = json_object_new_array();
json_object_object_add(root_node,"hashlist", hash_list_node);
return(hash_ok);
}
hash_list_node = json_object_new_array();
pthread_mutex_lock(&listmutex);
mylist = hash_list;
while ((mylist)&&(mylist->username))
{
jchild = json_object_new_object();
jobj = json_object_new_string(mylist->username);
json_object_object_add(jchild,"username", jobj);
str2hex(mylist->hash, buff, hash_ret_len);
jobj = json_object_new_string(buff);
json_object_object_add(jchild,"hash", jobj);
jobj = json_object_new_string(mylist->salt);
json_object_object_add(jchild,"salt", jobj);
jobj = json_object_new_string(mylist->salt);
json_object_object_add(jchild,"salt", jobj);
jobj = json_object_new_string(mylist->salt2);
json_object_object_add(jchild,"salt2", jobj);
json_object_array_add(hash_list_node,jchild);
mylist = mylist->next;
}
pthread_mutex_unlock(&listmutex);
json_object_object_add(root_node,"hashlist", hash_list_node);
#endif
return hash_ok;
}
OSStatus system_easylink_wac_start( mico_Context_t * const inContext )
{
OSStatus err = kNoErr;
IPStatusTypedef para;
uint8_t major_ver, minor_ver, revision;
mfi_wac_lib_version( &major_ver, &minor_ver, &revision );
system_log( "Import MFi WAC library v%d.%d.%d", major_ver, minor_ver, revision );
WACPlatformParameters_t* WAC_Params = NULL;
WAC_Params = calloc(1, sizeof(WACPlatformParameters_t));
require(WAC_Params, exit);
micoWlanGetIPStatus(¶, Station);
str2hex((unsigned char *)para.mac, WAC_Params->macAddress, 6);
WAC_Params->isUnconfigured = 1;
WAC_Params->supportsAirPlay = 0;
WAC_Params->supportsAirPrint = 0;
WAC_Params->supports2_4GHzWiFi = 1;
WAC_Params->supports5GHzWiFi = 0;
WAC_Params->supportsWakeOnWireless = 0;
WAC_Params->firmwareRevision = FIRMWARE_REVISION;
WAC_Params->hardwareRevision = HARDWARE_REVISION;
WAC_Params->serialNumber = SERIAL_NUMBER;
WAC_Params->name = inContext->flashContentInRam.micoSystemConfig.name;
WAC_Params->model = MODEL;
WAC_Params->manufacturer = MANUFACTURER;
WAC_Params->numEAProtocols = 1;
WAC_Params->eaBundleSeedID = BUNDLE_SEED_ID;
WAC_Params->eaProtocols = (char **)eaProtocols;
err = mfi_wac_start( inContext, WAC_Params, MICO_I2C_CP, 1200 );
require_noerr(err, exit);
exit:
free(WAC_Params);
return err;
}
int main(int argc, char *argv[])
{
char *buf = NULL;
size_t len_buf = 0;
if (argc < 2)
{
printf("Usage: %s filename\n", argv[0]);
return -1;
}
if ( ! t_read_full_file(argv[1], &buf, &len_buf, 0))
{
printf("read file \"%s\" failed!\n", argv[1]);
return -1;
}
len_buf -= 1;
//t_disbuf(buf, len_buf);
if (str2hex(&buf, (u32*)&len_buf) < 0)
{
printf("string to hex failed!\n");
return -1;
}
if ( ! process_keda_protocol(&buf, (u32*)&len_buf))
{
puts("process keda failed!");
return -1;
}
free(buf);
buf = NULL;
return 0;
}
int dns_get_answer(char* argval)
{
char *field, *saveptr1=NULL;
char field1[512], field2[512], field3[512];
int i, len, num_params;
u_int16_t TYPE=1; // A
u_int8_t *ptrTYPE;
u_int32_t TTL=0;
u_int8_t *ptrTTL;
u_int16_t RDLEN;
u_int8_t *ptrRDLEN;
u_int8_t rdata[512];
field1[0]='\0';
field2[0]='\0';
field3[0]='\0';
len = strlen (argval);
// determine number of occurences of ':'
num_params=1;
for (i=0; i<len; i++)
{
if (argval[i]==':') num_params++;
}
if (num_params>3) return 0; // Error!
// now get the fields (type, ttl, rdata)
field = strtok_r(argval, ":", &saveptr1);
strncpy(field1, field, 512);
if (num_params>1) // 2 or 3
{
field = strtok_r(NULL, ":", &saveptr1);
strncpy(field2, field, 512);
if (num_params==3)
{
field = strtok_r(NULL, ":", &saveptr1);
strncpy(field3, field, 512);
}
}
// Now we have all parameters in field1, field2, and field3.
// But field2 and/or field3 might be empty.
switch (num_params)
{
case 1: // only RDATA specified
strncpy(field3, field1, 512);
strcpy(field1, "A");
strcpy(field2, "0");
break;
case 2: // TYPE and RDATA
strncpy(field3, field2, 512);
strcpy(field2, "0");
break;
}
//CHECK:
//printf("fields: [%s] [%s] [%s]\n",field1,field2,field3);
//////////////////////////////////////////////////////////////////////
// Now create the whole answer section: Type, Class, TTL, RDLEN, RDATA
//// TYPE
if ( (strcmp(field1,"CNAME")==0) ||
(strcmp(field1,"cname")==0) )
{
TYPE=5;
gbuf[0]=0x00;
gbuf[1]=0x05;
}
else if ( (strcmp(field1,"A")==0) ||
(strcmp(field1,"a")==0) )
{
TYPE=1;
gbuf[0]=0x00;
gbuf[1]=0x01;
}
else // type must be given as number
{
TYPE = (u_int16_t) str2int(field1);
ptrTYPE = (u_int8_t*) &TYPE;
gbuf[0]=*(ptrTYPE+1);
gbuf[1]=*(ptrTYPE);
}
//// CLASS = IN = 0x00 01
gbuf[2]= 0x00; gbuf[3]=0x01;
//// TTL
TTL = (u_int32_t) str2int(field2);
ptrTTL = (u_int8_t*) &TTL;
gbuf[4]= *(ptrTTL+3);
gbuf[5]= *(ptrTTL+2);
gbuf[6]= *(ptrTTL+1);
gbuf[7]= *(ptrTTL+0);
//// RDLEN and RDATA
if (TYPE==1) // A
{
RDLEN = num2hex(field3, rdata); // should be 4 if IP address
if (RDLEN!=4)
{
fprintf(stderr," mz/dns_get_answer: [WARNING] RDATA of A record should contain an IPv4 address (4 bytes).\n");
}
}
else if (TYPE==5) // CNAME
{
RDLEN = dns_process_label (field3, rdata);
if (RDLEN==0)
{
fprintf(stderr," mz/dns_get_answer: [WARNING] RDATA must contain a domain name.\n");
}
}
else // Any other type
{
RDLEN = str2hex(field3, rdata, 512); // should be 4 if IP address
}
ptrRDLEN = (u_int8_t*) &RDLEN;
gbuf[8] = *(ptrRDLEN+1);
gbuf[9] = *(ptrRDLEN+0);
// finally write rdata
for (i=0; i<RDLEN; i++)
{
gbuf[10+i] = rdata[i];
}
gbuf_s = 10+RDLEN;
//////// TEST
/*
for (i=0; i<gbuf_s; i++)
{
printf("%02x \n",gbuf[i]);
}
printf("i=%u\n",i);
*/
return 1;
}
/**
@func wmmp_readAppData
@brief 读取wmmp接收数据
@param[in] flowID wmmp流通道
@param[out] buf 输出BUFF指针
@param[in-out] len 输入BUFF的最大长度，输出接收数据的实际长度
@return 0-成功； 其他值-失败
*/
int wmmp_readAppData(int flowID, char *buf, int *len)
{
int rc;
int i;
int tmpflowID;
int tmplen;
int readlen;
int timeout;
time_t now,last;
int retry;
//char testbuf[4096];
//char *p;
char ch;
#ifdef WMMP_READ_DEBUG
int fp;
#endif
#ifdef WMMP_READ_DEBUG
fp = fopen("/temp.txt","ab+");
if(fp == -1)
{
DEBUG_PRINTF("open file error\n");
exit -1;
}
fwrite("start", 5, 1, fp);
#endif
//int fd_ttys2;
//fd_ttys2 = port_open("/dev/ttyS2");
//char recbuf[APP_RECV_PACKET_MAXLEN*2+1]="";
DEBUG_PRINTF("wmmp read data\n");
retry = 2;
while(retry --)
{
//modem_flushInputBuffer();
rc = wmmp_waitResponse(NULL,60);
if(rc != 0)
{
DEBUG_PRINTF("WMMP get response error: %x\n",rc);
goto ExitProcessing;
}
// printf("rev4 = %s\n", wmmp_rx_buf.line[0]);
// printf("*retry = %d\n", retry);
if(wmmp_rx_buf.enumResponseType != RESPONSE_WMMP_MSG)
{
DEBUG_PRINTF("unexpected response: %d\n",wmmp_rx_buf.enumResponseType);
//rc = MODEM_ERROR_NUM(MODEM_ERROR_WMMP,ERROR_WMMP_BAD_RESPONSE);
//goto ExitProcessing;
continue;
}
if(sscanf(wmmp_rx_buf.line[0],"$M2MMSG: 7,%d,%d",&tmpflowID,&readlen) != 2)
{
DEBUG_PRINTF("expected msg not found\n");
//rc = MODEM_ERROR_NUM(MODEM_ERROR_WMMP,ERROR_WMMP_BAD_RESPONSE);
//goto ExitProcessing;
continue;
}
/*printf("flowID = %d \nlen = %d\n",tmpflowID, readlen);*/
if(tmpflowID != flowID)
{
DEBUG_PRINTF("unexpected flowID\n");
rc = MODEM_ERROR_NUM(MODEM_ERROR_WMMP,ERROR_WMMP_BAD_RESPONSE);
goto ExitProcessing;
}
if((readlen > APP_RECV_PACKET_MAXLEN) || (readlen > *len))
{
DEBUG_PRINTF("readlen overflow!!!readlen=%d\n",readlen);
rc = MODEM_ERROR_NUM(MODEM_ERROR_WMMP,ERROR_WMMP_APPREAD_OVERFLOW);
goto ExitProcessing;
}
break;
}
if( retry < 0 )
{
DEBUG_PRINTF("expected msg not found\n");
rc = MODEM_ERROR_NUM(MODEM_ERROR_WMMP,ERROR_WMMP_BAD_RESPONSE);
goto ExitProcessing;
}
#if 0
//wait data ?
timeout = 5000;
do
{
tmplen = modem_charsInBuffer();
//DEBUG_PRINTF("read data len = %d\n",tmplen);
timeout --;
}while( (tmplen < (readlen*2)) && (timeout >0));
if(timeout <= 0)
{
DEBUG_PRINTF("read data len = %d\n",tmplen);
DEBUG_PRINTF("read data timeout\n");
// rc = MODEM_ERROR_NUM(MODEM_ERROR_DEVICE,MODEM_DEVICE_TIMEOUT);
// goto ExitProcessing;
}
//read data into wmmp_rx_buf.buf
modem_read(wmmp_rx_buf.buf,readlen*2);
#endif
#if 0
//DEBUG_PRINTF("init response rx buffer\n");
sleep(3);
wmmp_initRxBuffer();
time(&last);
do
{
#if 0
tmplen = modem_charsInBuffer();
if(tmplen != 0)
{
modem_read(wmmp_rx_buf.buf_tail,tmplen);
wmmp_rx_buf.buf_tail += tmplen;
*(wmmp_rx_buf.buf_tail) = '\0';
wmmp_rx_buf.rxlen += tmplen;
DEBUG_PRINTF("read data len = %d\n",wmmp_rx_buf.rxlen);
}
#else
//if(modem_charsInBuffer()){
if(modem_read( wmmp_rx_buf.buf_tail, 1) == 1)
//if(modem_read( &ch, 1) == 1)
{
//fwrite(&ch, 1, 1, fp);
//modem_read( wmmp_rx_buf.buf_tail, 1);
//DEBUG_PRINTF("%c",*wmmp_rx_buf.buf_tail);
//write(fd_ttys2,wmmp_rx_buf.buf_tail,1);
fwrite(wmmp_rx_buf.buf_tail, 1, 1, fp);
wmmp_rx_buf.buf_tail++;
// *(wmmp_rx_buf.buf_tail) = '\0';
wmmp_rx_buf.rxlen++;
}
#endif
if(wmmp_rx_buf.rxlen < readlen*2)
{
time(&now);
if(now > last + 60) //timeout 60s
{
DEBUG_PRINTF("read data len = %d\n",wmmp_rx_buf.rxlen);
DEBUG_PRINTF("read data timeout\n");
rc = MODEM_ERROR_NUM(MODEM_ERROR_DEVICE,MODEM_DEVICE_TIMEOUT);
goto ExitProcessing;
}
}
else
break;
}while(1);
#endif
//20100417 for uart overrun error@115200bps
#if 1
timeout=35000;
int recLen = 0;
/*printf("star receive!\n");*/
wmmp_initRxBuffer();
do
{
recLen = modem_read( wmmp_rx_buf.buf_tail, readlen*2-wmmp_rx_buf.rxlen);
if(recLen != 0)
{
#ifdef WMMP_READ_DEBUG
fwrite(wmmp_rx_buf.buf_tail, 1, recLen, fp);
#endif
wmmp_rx_buf.buf_tail += recLen;
// *(wmmp_rx_buf.buf_tail) = '\0';
wmmp_rx_buf.rxlen += recLen;
DEBUG_PRINTF("wmmp_rx_buf.rxlen = %d\n", wmmp_rx_buf.rxlen);
}
}while((wmmp_rx_buf.rxlen < readlen*2) && timeout-- );
// printf("readlen*2 = %d\n",readlen*2);
// printf("wmmp_rx_buf.rxlen = %d\n",wmmp_rx_buf.rxlen);
if(timeout <= 0)
{
rc = MODEM_ERROR_NUM(MODEM_ERROR_DEVICE,MODEM_DEVICE_TIMEOUT);
goto ExitProcessing;
}
#endif
//Decode hex into str
tmplen = str2hex(wmmp_rx_buf.buf,readlen*2,buf,*len);
/*printf("%s",buf);*/
//normal return
#ifdef WMMP_READ_DEBUG
fwrite("end", 3, 1, fp);
fclose(fp);
#endif
*len = tmplen;
return 0;
//error process
ExitProcessing:
#ifdef WMMP_READ_DEBUG
fwrite("end", 3, 1, fp);
fclose(fp);
#endif
*len = 0;
return rc;
}
static void
bootpath_fake(struct bootpath *bp, const char *cp)
{
const char *pp;
int v0val[3];
#define BP_APPEND(BP,N,V0,V1,V2) { \
strcpy((BP)->name, N); \
(BP)->val[0] = (V0); \
(BP)->val[1] = (V1); \
(BP)->val[2] = (V2); \
(BP)++; \
nbootpath++; \
}
#if defined(SUN4)
if (CPU_ISSUN4M) {
printf("twas brillig..\n");
return;
}
#endif
pp = cp + 2;
v0val[0] = v0val[1] = v0val[2] = 0;
if (*pp == '(' /* for vi: ) */
&& *(pp = str2hex(++pp, &v0val[0])) == ','
&& *(pp = str2hex(++pp, &v0val[1])) == ',')
(void)str2hex(++pp, &v0val[2]);
#if defined(SUN4)
if (CPU_ISSUN4) {
char tmpname[8];
/*
* xylogics VME dev: xd, xy, xt
* fake looks like: /vme0/xdc0/xd@1,0
*/
if (cp[0] == 'x') {
if (cp[1] == 'd') {/* xd? */
BP_APPEND(bp, "vme", -1, 0, 0);
} else {
BP_APPEND(bp, "vme", -1, 0, 0);
}
sprintf(tmpname,"x%cc", cp[1]); /* e.g. `xdc' */
BP_APPEND(bp, tmpname, -1, v0val[0], 0);
sprintf(tmpname,"x%c", cp[1]); /* e.g. `xd' */
BP_APPEND(bp, tmpname, v0val[1], v0val[2], 0);
return;
}
/*
* ethernet: ie, le (rom supports only obio?)
* fake looks like: /obio0/le0
*/
if ((cp[0] == 'i' || cp[0] == 'l') && cp[1] == 'e') {
BP_APPEND(bp, "obio", -1, 0, 0);
sprintf(tmpname,"%c%c", cp[0], cp[1]);
BP_APPEND(bp, tmpname, -1, 0, 0);
return;
}
/*
* scsi: sd, st, sr
* assume: 4/100 = sw: /obio0/sw0/sd@0,0:a
* 4/200 & 4/400 = si/sc: /vme0/si0/sd@0,0:a
* 4/300 = esp: /obio0/esp0/sd@0,0:a
* (note we expect sc to mimic an si...)
*/
if (cp[0] == 's' &&
(cp[1] == 'd' || cp[1] == 't' || cp[1] == 'r')) {
int target, lun;
switch (cpuinfo.cpu_type) {
case CPUTYP_4_200:
case CPUTYP_4_400:
BP_APPEND(bp, "vme", -1, 0, 0);
BP_APPEND(bp, "si", -1, v0val[0], 0);
break;
case CPUTYP_4_100:
BP_APPEND(bp, "obio", -1, 0, 0);
BP_APPEND(bp, "sw", -1, v0val[0], 0);
break;
case CPUTYP_4_300:
BP_APPEND(bp, "obio", -1, 0, 0);
BP_APPEND(bp, "esp", -1, v0val[0], 0);
break;
default:
panic("bootpath_fake: unknown system type %d",
cpuinfo.cpu_type);
}
/*
* Deal with target/lun encodings.
* Note: more special casing in dk_establish().
*
* We happen to know how `prom_revision' is
* constructed from `monID[]' on sun4 proms...
*/
if (prom_revision() > '1') {
target = v0val[1] >> 3; /* new format */
lun = v0val[1] & 0x7;
} else {
// :020000040800F2
// :1000000000100020470100085501000857010008B2
// :10001000590100085B0100085D01000800000000B4
// .
// .
// .
int HexChecksumError(char *p) {
int err,n=str2hex(&p,2);
for(err=n;n-- > -5;err+=str2hex(&p,2));
return(err & 0xff);
}
int Cregdeal::userinfo_reg_account(char* recvbuf, int rcvlen, char** sendbuf, int* sndlen)
{
int ret;
uint32_t userid, user_id_exist = 0;
char passwd[PASSWD_SIZE/2];
char safe_str[SAFE_STR_SIZE];
PROTO_HEAD_PTR hdp;
USERINFO_REG_BODY_REQ_PTR byp;
uint32_t pkg_len = ntohl(*(uint32_t *)recvbuf);
if (pkg_len != (PROTO_HEAD_SIZE + USERINFO_REG_REQ_BODY_SIZE)
&& pkg_len != (PROTO_HEAD_SIZE + USERINFO_REG_EXT_BODY_SIZE)) {
DEBUG_LOG("USERINFO PKG LEN ERROR\t[pkglen=%u expected len=%u or %u]",
pkg_len, (PROTO_HEAD_SIZE + USERINFO_REG_REQ_BODY_SIZE), (PROTO_HEAD_SIZE
+ USERINFO_REG_EXT_BODY_SIZE));
return REG_SIZE_ERR;
}
hdp = (PROTO_HEAD_PTR)recvbuf;
byp = (USERINFO_REG_BODY_REQ_PTR)(recvbuf + PROTO_HEAD_SIZE);
str2hex(byp->passwd, PASSWD_SIZE, passwd);
safe_str_copy(byp->email, safe_str, EMAIL_SIZE); //safe copy
//check the email here
//not include `@` is error
TRIM_INVAD_EMAIL(safe_str, EMAIL_SIZE);
if (!strchr(safe_str, '@')) {
DEBUG_LOG("INVALID EMAIL ADDRESS\t[%s]", safe_str);
return INVALID_EMAIL;
}
// check if number of registered ids today have or haven't exceeded the max limit
if (((client_ip & 0xFFFF) != 0XA8C0)
&& (client_ip != 0X7D635072)
&& (client_ip != 0X76635072)
&& (client_ip != 0X92635072)
&& (client_ip != 0X9A635072)
&& (client_ip != 0XCA635072)
&& (client_ip != 0XCB635072)
&& (client_ip != 0XCC635072)
&& (!this->check_count_ip(client_ip))) {
DEBUG_LOG("enter ip count");
char rcv[4];
struct ip_cnt {
uint32_t commdid;
uint32_t ip;
} ip_check;
ip_check.commdid = htonl(1);
ip_check.ip = client_ip;
if (net->net_io(reinterpret_cast<char*>(&ip_check), 8, rcv, 4) != 4) {
DEBUG_LOG("ERROR OCCURRED WHILE CHECKING IP COUNT");
} else {
uint32_t cnt;
memcpy(&cnt, rcv, 4);
cnt = ntohl(cnt);
if (cnt > MAX_REG_CNT) {
DEBUG_LOG("NUM OF REG IDS EXCEEDED PER IP MAX LIMIT\t[ip=%u cnt=%u]", client_ip, cnt);
return REG_CNT_ERR;
}
}
}
Label:
//得到userid
//ret = this->regact->create_user_id(userid);
userid_get_userid_out ret_out;
ret=cpo->userid_get_userid(& ret_out );
if (ret != SUCCESS) {
DEBUG_LOG("FAIL TO GET A USER ID");
return CUSER_ID_CREATE_ERR;
}
userid=ret_out.userid;
//send information to db
userinfo_register_ex_in user_db;
memset(&user_db, 0x00, sizeof (userinfo_register_ex_in));
memcpy(user_db.passwd, passwd, sizeof (passwd));
// Make sure the value of `sex` is 0 or 1
user_db.sex = !!(byp->sex);
user_db.birthday = ntohl(byp->birthday);
memcpy(user_db.email, safe_str, EMAIL_SIZE);
user_db.reg_addr_type = ntohl(byp->location);
user_db.ip = client_ip;
if (pkg_len == (PROTO_HEAD_SIZE + USERINFO_REG_EXT_BODY_SIZE)) {
//include extended information here
char *extend_data = byp->data;
uint16_t t_data;
memcpy(user_db.mobile, extend_data, TEL_SIZE);
extend_data += TEL_SIZE;
memcpy(&t_data, extend_data, sizeof(t_data));
user_db.addr_province = htons(t_data);
extend_data += PROV_SIZE;
memcpy(&t_data, extend_data, sizeof(t_data));
user_db.addr_city = ntohs(t_data);
extend_data += CITY_SIZE;
memcpy(user_db.addr, extend_data, ADR_SIZE);
extend_data += ADR_SIZE;
memcpy(user_db.signature, extend_data, SIG_SIZE);
}
ret = cpo->userinfo_register(userid, &user_db, &user_id_exist);
if (ret != SUCCESS) {
DEBUG_LOG("DB ERR\t[uid=%u ret=%d]", userid, ret);
if (ret == 1104) { // User ID already existed
goto Label;
}
//this->regact->cancel_user_id(userid);
cpo->userid_set_noused(userid );
return ret;
}
if (set_sndbuf_head(sendbuf, sndlen, (PROTO_HEAD_PTR)recvbuf, SESSION_LEN, SUCCESS) != SUCCESS) {
//this->regact->cancel_user_id(userid);
return REG_SYS_ERR;
}
uint32_t inbuf[4];
inbuf[0] = client_ip;
inbuf[1] = time(0);
inbuf[2] = userid;
inbuf[3] = inbuf[1];
des_encrypt_n(LOGIN_DES_KEY, (char *)inbuf, (char *)(*sendbuf + PROTO_HEAD_SIZE), 2);
((PROTO_HEAD_PTR)*sendbuf)->userid = htonl(userid);
INFO_LOG("userid[%u]email[%s]sex[%c]birth[%u]", userid, safe_str,
byp->sex, ntohl(byp->birthday));
DEBUG_LOG("REG FROM CHANNEL\t[%u]", user_db.reg_addr_type);
// stat client
time_t ts = time(0);
uint32_t tmp = 1;
// 统计消息起始ID 0x2010101
/* 0:51mole 1:92game 2:766
3:QQ空间 4:7K7K 5:4399
6:3839 7:2144 8:小游戏
9:唤醒 10:向导 11:QQ礼活动
12:摩尔大使 13:QQmini 14:4399xyx
15:cks 16:yx007 17:新浪
18:宏梦 19:19 20:彩虹堂
21:gameyes 22:游戏22 23:41717小游戏
24:f1212 25:游戏82 26:翼动小游戏
27:成都小游戏网 28:92小游戏
29: 大玩国 30:赛尔, 31哈奇小镇, 32 61.com*/
if (user_db.reg_addr_type > max_register_channel) {
user_db.reg_addr_type = 0;
}
DEBUG_LOG("====MAX %u", max_register_channel);
msglog(statfile, 0x06010101 + user_db.reg_addr_type, ts, &tmp, sizeof(uint32_t));
msglog(statfile, 0x06010001, ts, &userid, 4);
// this->regact->send_email(safe_str[0], pUtil->get_config_strval("send_mail_cmd"), userid, safe_str[1]);
DEBUG_LOG("---------------REGISTER ACCOUNT END (SUCCESS)-------------");
////////for mole emissary
/*
if (ntohl(byp->location) == MOLE_EMISSARY_LOC) {
LOG(7, "email : [%64.64s]", byp->email);
LOG(7, "cmd : [%s]", pUtil->get_config_strval("send_mole_mail_cmd"));
this->regact->send_mole_emissary_email(byp->email, pUtil->get_config_strval("send_mole_mail_cmd"), userid);
}
*/
return SUCCESS;
}
int application_start(void)
{
OSStatus err = kNoErr;
net_para_st para;
Platform_Init();
/*Read current configurations*/
context = ( mico_Context_t *)malloc(sizeof(mico_Context_t) );
require_action( context, exit, err = kNoMemoryErr );
memset(context, 0x0, sizeof(mico_Context_t));
mico_rtos_init_mutex(&context->flashContentInRam_mutex);
mico_rtos_init_semaphore(&context->micoStatus.sys_state_change_sem, 1);
MICOReadConfiguration( context );
err = MICOInitNotificationCenter ( context );
err = MICOAddNotification( mico_notify_READ_APP_INFO, (void *)micoNotify_ReadAppInfoHandler );
require_noerr( err, exit );
/*wlan driver and tcpip init*/
mxchipInit();
getNetPara(¶, Station);
formatMACAddr(context->micoStatus.mac, (char *)¶.mac);
mico_log_trace();
mico_log("%s mxchipWNet library version: %s", APP_INFO, system_lib_version());
/*Start system monotor thread*/
err = MICOStartSystemMonitor(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the system monitor.") );
err = MICORegisterSystemMonitor(&mico_monitor, APPLICATION_WATCHDOG_TIMEOUT_SECONDS*1000);
require_noerr( err, exit );
mico_init_timer(&_watchdog_reload_timer,APPLICATION_WATCHDOG_TIMEOUT_SECONDS*1000-100, _watchdog_reload_timer_handler, NULL);
mico_start_timer(&_watchdog_reload_timer);
if(context->flashContentInRam.micoSystemConfig.configured != allConfigured){
mico_log("Empty configuration. Starting configuration mode...");
#ifdef CONFIG_MODE_EASYLINK
err = startEasyLink( context );
require_noerr( err, exit );
#endif
#ifdef CONFIG_MODE_WAC
WACPlatformParameters_t* WAC_Params = NULL;
WAC_Params = calloc(1, sizeof(WACPlatformParameters_t));
require(WAC_Params, exit);
str2hex((unsigned char *)para.mac, WAC_Params->macAddress, 6);
WAC_Params->isUnconfigured = 1;
WAC_Params->supportsAirPlay = 0;
WAC_Params->supportsAirPrint = 0;
WAC_Params->supports2_4GHzWiFi = 1;
WAC_Params->supports5GHzWiFi = 0;
WAC_Params->supportsWakeOnWireless = 0;
WAC_Params->firmwareRevision = FIRMWARE_REVISION;
WAC_Params->hardwareRevision = HARDWARE_REVISION;
WAC_Params->serialNumber = SERIAL_NUMBER;
WAC_Params->name = context->flashContentInRam.micoSystemConfig.name;
WAC_Params->model = MODEL;
WAC_Params->manufacturer = MANUFACTURER;
WAC_Params->numEAProtocols = 1;
WAC_Params->eaBundleSeedID = BUNDLE_SEED_ID;
WAC_Params->eaProtocols = (char **)eaProtocols;;
err = startMFiWAC( context, WAC_Params, 1200);
free(WAC_Params);
require_noerr( err, exit );
#endif
}
else{
mico_log("Available configuration. Starting Wi-Fi connection...");
/* Regisist notifications */
err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WiFI_PARA_CHANGED, (void *)micoNotify_WiFIParaChangedHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_DHCP_COMPLETED, (void *)micoNotify_DHCPCompleteHandler );
require_noerr( err, exit );
if(context->flashContentInRam.micoSystemConfig.rfPowerSaveEnable == true){
ps_enable();
}
if(context->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable == true){
mico_mcu_powersave_config(true);
}
/*Bonjour service for searching*/
// if(context->flashContentInRam.micoSystemConfig.bonjourEnable == true){
// err = MICOStartBonjourService( Station, context );
// require_noerr( err, exit );
// }
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "mDNSResponder", mDNSResponder_thread, 0x1000, (void*)context );
require_noerr_action( err, exit, mico_log("ERROR: Unable to start mDNSResponder thread.") );
/*Local configuration server*/
if(context->flashContentInRam.micoSystemConfig.configServerEnable == true){
err = MICOStartConfigServer(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the local server thread.") );
}
/*Start mico application*/
err = MICOStartApplication( context );
require_noerr( err, exit );
_ConnectToAP( context );
}
/*System status changed*/
while(mico_rtos_get_semaphore(&context->micoStatus.sys_state_change_sem, MICO_WAIT_FOREVER)==kNoErr){
switch(context->micoStatus.sys_state){
case eState_Normal:
break;
case eState_Software_Reset:
sendNotifySYSWillPowerOff();
mico_thread_msleep(500);
PlatformSoftReboot();
break;
case eState_Wlan_Powerdown:
sendNotifySYSWillPowerOff();
mico_thread_msleep(500);
wifi_power_down();
break;
case eState_Standby:
mico_log("Enter standby mode");
sendNotifySYSWillPowerOff();
mico_thread_msleep(200);
wifi_power_down();
Platform_Enter_STANDBY();
break;
default:
break;
}
}
require_noerr_action( err, exit, mico_log("Closing main thread with err num: %d.", err) );
exit:
mico_rtos_delete_thread(NULL);
return kNoErr;
}
int
main(int argc, char **argv)
{
int rv;
const char *what;
const char *filename;
const char *outname;
TheImg4 *img4;
unsigned type;
unsigned written;
unsigned char ivkey[16 + 32];
unsigned char *iv = NULL, *key = NULL;
unsigned char *output = NULL;
unsigned outlen = 0;
int outdup = 0;
DERItem item;
unsigned char *data;
size_t size;
if (argc < 4) {
fprintf(stderr, "usage: %s {-image|-extra|-keybag|-ticket} input output [ivkey]\n", argv[0]);
return 1;
}
what = argv[1];
filename = argv[2];
outname = argv[3];
if (argc > 4) {
rv = str2hex(sizeof(ivkey), ivkey, argv[4]);
if (rv == sizeof(ivkey)) {
iv = ivkey;
key = ivkey + 16;
}
}
data = read_file(filename, 0, &size);
if (data == NULL) {
fprintf(stderr, "[e] cannot read '%s'\n", filename);
return -1;
}
img4 = parse(data, size);
if (!img4) {
fprintf(stderr, "[e] cannot parse '%s'\n", filename);
free(data);
return -1;
}
rv = Img4DecodeGetPayloadType(img4, &type);
if (rv) {
fprintf(stderr, "[e] cannot identify '%s'\n", filename);
goto err;
}
printf("%c%c%c%c\n", FOURCC(type));
if (!strncmp(what, "-i", 2) || !strncmp(what, "-e", 2)) {
int decompress;
rv = Img4DecodeGetPayload(img4, &item);
if (rv) {
fprintf(stderr, "[e] cannot extract payload from '%s'\n", filename);
goto err;
}
output = item.data;
outlen = item.length;
if (iv && key) {
if (outlen & 15) {
unsigned usize = (outlen + 15) & ~15;
unsigned char *tmp = calloc(1, usize);
if (!tmp) {
fprintf(stderr, "[e] out of memory %u\n", usize);
goto err;
}
memcpy(tmp, output, outlen);
OUTSET(tmp);
}
rv = Img4DecodeGetPayloadKeybag(img4, &item);
if (rv || item.length == 0) {
fprintf(stderr, "[w] image '%s' has no keybag\n", filename);
}
#ifdef USE_CORECRYPTO
cccbc_one_shot(ccaes_cbc_decrypt_mode(), 32, key, iv, (outlen + 15) / 16, output, output);
#else
AES_KEY decryptKey;
AES_set_decrypt_key(key, 256, &decryptKey);
AES_cbc_encrypt(output, output, (outlen + 15) & ~15, &decryptKey, iv, AES_DECRYPT);
#endif
}
#ifdef iOS10
if (img4->payload.compression.data && img4->payload.compression.length) {
DERItem tmp[2];
uint32_t deco = 0;
uint64_t usize = 0;
if (DERParseSequenceContent(&img4->payload.compression, 2, DERImg4PayloadItemSpecs10c, tmp, 0) ||
DERParseInteger(&tmp[0], &deco) || DERParseInteger64(&tmp[1], &usize)) {
fprintf(stderr, "[e] cannot get decompression info\n");
goto err;
}
if (deco == 1 && what[1] == 'i') {
size_t asize = lzfse_decode_scratch_size();
unsigned char *dec, *aux = malloc(asize);
if (!aux) {
fprintf(stderr, "[e] out of memory %zu\n", asize);
goto err;
}
dec = malloc(usize + 1);
if (!dec) {
fprintf(stderr, "[e] out of memory %llu\n", usize + 1);
free(aux);
goto err;
}
outlen = lzfse_decode_buffer(dec, usize + 1, output, outlen, aux);
free(aux);
if (outlen != usize) {
fprintf(stderr, "[e] decompression error\n");
free(dec);
goto err;
}
OUTSET(dec);
}
}
#endif
decompress = (DWORD_BE(output, 0) == 'comp' && DWORD_BE(output, 4) == 'lzss');
if (decompress && what[1] == 'i') {
uint32_t csize = DWORD_BE(output, 16);
uint32_t usize = DWORD_BE(output, 12);
uint32_t adler = DWORD_BE(output, 8);
unsigned char *dec = malloc(usize);
if (outlen > 0x180 + csize) {
fprintf(stderr, "[i] extra 0x%x bytes after compressed chunk\n", outlen - 0x180 - csize);
}
if (!dec) {
fprintf(stderr, "[e] out of memory %u\n", usize);
goto err;
}
outlen = decompress_lzss(dec, output + 0x180, csize);
if (adler != lzadler32(dec, outlen)) {
fprintf(stderr, "[w] adler32 mismatch\n");
}
OUTSET(dec);
} else if (decompress) {
uint32_t csize = DWORD_BE(output, 16);
uint32_t usize = outlen - 0x180 - csize;
if (outlen > 0x180 + csize) {
unsigned char *dec = malloc(usize);
if (!dec) {
fprintf(stderr, "[e] out of memory %u\n", usize);
goto err;
}
memcpy(dec, output + 0x180 + csize, usize);
outlen = usize;
OUTSET(dec);
} else {
OUTSET(NULL);
}
} else if (what[1] == 'e') {
OUTSET(NULL);
}
if (!output) {
fprintf(stderr, "[e] nothing to do\n");
goto err;
}
}
if (!strncmp(what, "-k", 2)) {
rv = Img4DecodeGetPayloadKeybag(img4, &item);
if (rv == 0 && item.length) {
output = item.data;
outlen = item.length;
} else {
fprintf(stderr, "[e] image '%s' has no keybag\n", filename);
goto err;
}
}
if (!strncmp(what, "-t", 2)) {
bool exists = false;
rv = Img4DecodeManifestExists(img4, &exists);
if (rv == 0 && exists) {
output = img4->manifestRaw.data;
outlen = img4->manifestRaw.length;
} else {
fprintf(stderr, "[e] image '%s' has no ticket\n", filename);
goto err;
}
}
written = write_file(outname, output, outlen);
if (written != outlen) {
fprintf(stderr, "[e] cannot write '%s'\n", outname);
goto err;
}
rv = 0;
out:
if (outdup) {
free(output);
}
free(img4);
free(data);
return rv;
err:
rv = -1;
goto out;
}
int application_start(void)
{
OSStatus err = kNoErr;
IPStatusTypedef para;
struct tm currentTime;
mico_rtc_time_t time;
char wifi_ver[64];
mico_log_trace();
#if 1
/*Read current configurations*/
context = ( mico_Context_t *)malloc(sizeof(mico_Context_t) );
require_action( context, exit, err = kNoMemoryErr );
memset(context, 0x0, sizeof(mico_Context_t));
mico_rtos_init_mutex(&context->flashContentInRam_mutex);
mico_rtos_init_semaphore(&context->micoStatus.sys_state_change_sem, 1);
MICOReadConfiguration( context );
err = MICOInitNotificationCenter ( context );
err = MICOAddNotification( mico_notify_READ_APP_INFO, (void *)micoNotify_ReadAppInfoHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WIFI_CONNECT_FAILED, (void *)micoNotify_ConnectFailedHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WIFI_Fatal_ERROR, (void *)micoNotify_WlanFatalErrHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_Stack_Overflow_ERROR, (void *)micoNotify_StackOverflowErrHandler );
require_noerr( err, exit );
#endif
/*wlan driver and tcpip init*/
MicoInit();
MicoSysLed(true);
/**********************add ethernet**********************/
add_ethernet();
//sleep(5000);
/*********************************************************/
mico_log("Free memory %d bytes", MicoGetMemoryInfo()->free_memory) ;
/* Enter test mode, call a build-in test function amd output on STDIO */
if(MicoShouldEnterMFGMode()==true)
mico_mfg_test();
/*Read current time from RTC.*/
MicoRtcGetTime(&time);
currentTime.tm_sec = time.sec;
currentTime.tm_min = time.min;
currentTime.tm_hour = time.hr;
currentTime.tm_mday = time.date;
currentTime.tm_wday = time.weekday;
currentTime.tm_mon = time.month - 1;
currentTime.tm_year = time.year + 100;
mico_log("Current Time: %s",asctime(¤tTime));
micoWlanGetIPStatus(¶, Station);
formatMACAddr(context->micoStatus.mac, (char *)¶.mac);
MicoGetRfVer(wifi_ver, sizeof(wifi_ver));
mico_log("%s mxchipWNet library version: %s", APP_INFO, MicoGetVer());
mico_log("Wi-Fi driver version %s, mac %s", wifi_ver, context->micoStatus.mac);
/*Start system monotor thread*/
err = MICOStartSystemMonitor(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the system monitor.") );
err = MICORegisterSystemMonitor(&mico_monitor, APPLICATION_WATCHDOG_TIMEOUT_SECONDS*1000);
require_noerr( err, exit );
mico_init_timer(&_watchdog_reload_timer,APPLICATION_WATCHDOG_TIMEOUT_SECONDS*1000 - 100, _watchdog_reload_timer_handler, NULL);
mico_start_timer(&_watchdog_reload_timer);
/* Regisist notifications */
err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler );
require_noerr( err, exit );
/*************add ethernet********Why add twice?***********/
//add_ethernet();
if(context->flashContentInRam.micoSystemConfig.configured != allConfigured){
mico_log("Empty configuration. Starting configuration mode...");
#if (MICO_CONFIG_MODE == CONFIG_MODE_EASYLINK) || (MICO_CONFIG_MODE == CONFIG_MODE_EASYLINK_WITH_SOFTAP)
err = startEasyLink( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_SOFT_AP)
err = startEasyLinkSoftAP( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_AIRKISS)
err = startAirkiss( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_WPS) || MICO_CONFIG_MODE == defined (CONFIG_MODE_WPS_WITH_SOFTAP)
err = startWPS( context );
require_noerr( err, exit );
#elif ( MICO_CONFIG_MODE == CONFIG_MODE_WAC)
WACPlatformParameters_t* WAC_Params = NULL;
WAC_Params = calloc(1, sizeof(WACPlatformParameters_t));
require(WAC_Params, exit);
str2hex((unsigned char *)para.mac, WAC_Params->macAddress, 6);
WAC_Params->isUnconfigured = 1;
WAC_Params->supportsAirPlay = 0;
WAC_Params->supportsAirPrint = 0;
WAC_Params->supports2_4GHzWiFi = 1;
WAC_Params->supports5GHzWiFi = 0;
WAC_Params->supportsWakeOnWireless = 0;
WAC_Params->firmwareRevision = FIRMWARE_REVISION;
WAC_Params->hardwareRevision = HARDWARE_REVISION;
WAC_Params->serialNumber = SERIAL_NUMBER;
WAC_Params->name = context->flashContentInRam.micoSystemConfig.name;
WAC_Params->model = MODEL;
WAC_Params->manufacturer = MANUFACTURER;
WAC_Params->numEAProtocols = 1;
WAC_Params->eaBundleSeedID = BUNDLE_SEED_ID;
WAC_Params->eaProtocols = (char **)eaProtocols;
err = startMFiWAC( context, WAC_Params, 1200);
free(WAC_Params);
require_noerr( err, exit );
#else
#error "Wi-Fi configuration mode is not defined"?
#endif
}
else{
mico_log("Available configuration. Starting Wi-Fi connection...");
err = MICOAddNotification( mico_notify_WiFI_PARA_CHANGED, (void *)micoNotify_WiFIParaChangedHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_DHCP_COMPLETED, (void *)micoNotify_DHCPCompleteHandler );
require_noerr( err, exit );
if(context->flashContentInRam.micoSystemConfig.rfPowerSaveEnable == true){
micoWlanEnablePowerSave();
}
if(context->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable == true){
MicoMcuPowerSaveConfig(true);
}
/*Local configuration server*/
if(context->flashContentInRam.micoSystemConfig.configServerEnable == true){
err = MICOStartConfigServer(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the local server thread.") );
}
err = MICOStartNTPClient(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the NTP client thread.") );
/*Start mico application*/
err = MICOStartApplication( context );
require_noerr( err, exit );
_ConnectToAP( context );
}
mico_log("Free memory %d bytes", MicoGetMemoryInfo()->free_memory) ;
/*System status changed*/
while(mico_rtos_get_semaphore(&context->micoStatus.sys_state_change_sem, MICO_WAIT_FOREVER)==kNoErr){
switch(context->micoStatus.sys_state){
case eState_Normal:
break;
case eState_Software_Reset:
sendNotifySYSWillPowerOff();
mico_thread_msleep(500);
MicoSystemReboot();
break;
case eState_Wlan_Powerdown:
sendNotifySYSWillPowerOff();
mico_thread_msleep(500);
micoWlanPowerOff();
break;
case eState_Standby:
mico_log("Enter standby mode");
sendNotifySYSWillPowerOff();
mico_thread_msleep(200);
micoWlanPowerOff();
MicoSystemStandBy(MICO_WAIT_FOREVER);
break;
default:
break;
}
}
require_noerr_action( err, exit, mico_log("Closing main thread with err num: %d.", err) );
exit:
mico_rtos_delete_thread(NULL);
return kNoErr;
}
int send_eth()
{
// Tasks:
// 1. Check 'eth_src_txt' and 'eth_dst_txt' which contain either a MAC address or a keyword
// 'eth_dst' can be set without having 'eth_src_txt' specified (the next 6 bytes of the
// 'arg_string' will be used). But if 'eth_src_txt' is given then also 'eth_dst_txt'
// should have been specified, otherwise a default (ff-ff-ff-ff-ff-ff) will be used.
// 2. Check whether 'arg_string' contains a hex-string. If YES then convert it into an
// 'eth_payload' and extract eth_type.
// 3. Apply 'padding' if specified
// 4. Check if frame has at least minimum length (14 Bytes).
// 5. Send frame 'count' times and
// 6. Apply 'delay' (make precautions for better delay functions)
int
src, // flag telling whether user has specified a source address
dst, // flag telling whether user has specified a destination address
src_random=0,
dst_random=0,
byte_ptr=1,
bytestring_s=0,
min_size=15,
pad=0,
repeat, loop, update,
i=0,
j=0;
char
err_buf[LIBNET_ERRBUF_SIZE],
message[MAX_PAYLOAD_SIZE*3];
u_int8_t bytestring[MAX_PAYLOAD_SIZE];
libnet_ptag_t t;
libnet_t *l;
if (tx.dot1Q)
{
fprintf(stderr," Note: raw layer 2 mode does not support 802.1Q builder.\n"
" If you want to create VLAN tags then you must do it by hand.\n");
exit(1);
}
if (tx.mpls)
{
fprintf(stderr," Note: raw layer 2 mode does not support MPLS builder.\n"
" If you want to create MPLS labels then you must do it by hand.\n");
exit(1);
}
// So other functions can use this function for sending Ethernet frames
// These other functions must set dst, src, type and payload!
if (tx.eth_params_already_set) goto ALL_SPECIFIED;
if ((tx.padding) && (tx.padding<15)) // Note: ignored if padding==0
{
tx.padding=15;
if (mz_port) {
cli_print(gcli, "Note: Set padding to 15 bytes (total length)\n");
} else
fprintf(stderr, " mz/send_eth: [Note] adjusted minimum frame size to 15 bytes.\n");
}
// Create a temporal, local bytestring:
//
for (i=0; i<MAX_PAYLOAD_SIZE; i++) bytestring[i]=0x00;
bytestring_s = str2hex (tx.arg_string, bytestring, MAX_PAYLOAD_SIZE);
// Set the flags to shorten subsequent decisions:
src = strlen(tx.eth_src_txt);
dst = strlen(tx.eth_dst_txt);
// IN ANY CASE if src has been specified:
//
if (src)
{
// Evaluate Ethernet CLI options (-a and -b)
if (check_eth_mac_txt(ETH_SRC)) // if true then problem!
{
// use own (already set in init.c)
}
src_random = tx.eth_src_rand; // local vars are faster
}
// IN ANY CASE if dst has been specified:
//
if (dst)
{
// Evaluate Ethernet CLI options (-a and -b)
if (check_eth_mac_txt(ETH_DST)) // if true then problem!
{
str2hex("ff:ff:ff:ff:ff:ff",tx.eth_dst, 6); // the default
}
dst_random = tx.eth_dst_rand; // local vars are faster
}
// Catch errors with too short bytestrings:
//
if (src)
{
// bytestring only needs to contain eth_type
min_size-=12;
}
else if (dst)
{
// bytstring must contain src and type
min_size-=6;
}
if (bytestring_s < min_size)
{
j = min_size - bytestring_s; // this is what's missing
bytestring_s += j; // note that bytestring has been filled up with 0x00, so we can do that
}
// ADDENDUM: If src specified, dst missing:
//
if ( (!dst) && (src) )
{
str2hex_mac ("ff:ff:ff:ff:ff:ff", tx.eth_dst);
}
// ADDENDUM: If dst specified, src missing:
//
if ((dst) && (!src))
{
// Get eth_src from bytestring:
if (bytestring_s>=6) {
(void) getbytes (bytestring, tx.eth_src, byte_ptr, byte_ptr+5);
byte_ptr=7; // now points to eth_type within bytestring
}
}
// FINALLY: If both dst and src have NOT been specified:
//
if ((!dst) && (!src))
{
if (bytestring_s>=6) {
(void) getbytes (bytestring, tx.eth_dst, byte_ptr, byte_ptr+5);
byte_ptr=7;
}
if (bytestring_s>=12) {
(void) getbytes (bytestring, tx.eth_src, byte_ptr, byte_ptr+5);
byte_ptr=13; // points to eth_type
}
}
// Set eth_type:
//
if (bytestring_s>=2) {
tx.eth_type = 256 * bytestring[byte_ptr-1] + bytestring[byte_ptr]; // don't forget: byte_ptr counts from 1 not 0
byte_ptr+=2; // points to first payload byte (if available)
}
// Get remaining payload:
//
if ( (tx.eth_payload_s = bytestring_s - byte_ptr +1) > 0 ) // if there are any remaining bytes
{
(void) getbytes (bytestring, tx.eth_payload, byte_ptr, bytestring_s);
}
// Add padding if desired.
// Note: padding means 'extend to given length' (not 'add these number of bytes')
if (tx.padding)
{
pad = tx.padding - (14 + tx.eth_payload_s); // number of additonal pad bytes required
for (i=0; i<pad; i++)
{
// tx.eth_payload[i+tx.eth_payload_s] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
tx.eth_payload[i+tx.eth_payload_s] = 0x00;
}
tx.eth_payload_s += pad;
}
ALL_SPECIFIED:
// *** All Ethernet parameters have been determined !
// *** Now let's send the frame!
l = libnet_init (LIBNET_LINK_ADV, tx.device, err_buf );
if (l == NULL)
{
fprintf(stderr, " mz/send_eth: libnet_init() failed (%s)", err_buf);
return -1;
}
repeat=1;
if (tx.count == 0)
{
loop = 1000000;
if (!quiet)
fprintf(stderr, " mz: !!! Infinite mode! Will send frames until you stop Mausezahn!!!\n");
}
else
loop = tx.count;
if ( (!quiet) && (!tx.delay) && (tx.count==0) )
fprintf(stderr, " mz: !!! Will send at maximum frame rate without feedback!!!\n");
t=0;
update=1;
// this is for the statistics:
mz_start = clock();
total_d = tx.count;
while (repeat)
{
if (tx.count!=0) repeat=0; // count=0 means repeat ad inifinitum
for (i=0; i<loop; i++)
{
if (src_random)
{
tx.eth_src[0] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256) & 0xFE;
tx.eth_src[1] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
tx.eth_src[2] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
tx.eth_src[3] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
tx.eth_src[4] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
tx.eth_src[5] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
update=1;
}
if (dst_random)
{
tx.eth_dst[0] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
tx.eth_dst[1] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
tx.eth_dst[2] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
tx.eth_dst[3] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
tx.eth_dst[4] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
tx.eth_dst[5] = (u_int8_t) ( ((float) rand()/RAND_MAX)*256);
update=1;
}
if (update) // new frame parameters
{
t = libnet_build_ethernet (tx.eth_dst,
tx.eth_src,
tx.eth_type,
tx.eth_payload,
tx.eth_payload_s,
l,
t);
if (t == -1)
{
fprintf(stderr, " mz/send_eth: %s", libnet_geterror(l));
return -1;
}
if (verbose)
{
bs2str (tx.eth_dst, message, 6); // DA
fprintf(stderr, " mz: send %s",message);
bs2str (tx.eth_src, message, 6); // SA
fprintf(stderr, " %s",message);
type2str(tx.eth_type, message);
fprintf(stderr, " %s",message); // Type
bs2str (tx.eth_payload, message, tx.eth_payload_s); // Payload
fprintf(stderr, " %s\n",message);
}
update=0;
if (verbose==2)
{
fprintf(stderr, "\n");
fprintf(stderr, "*** NOTE: Simulation only! Nothing has been sent! ***\n");
libnet_destroy(l);
return 0;
}
}
libnet_write(l);
if (tx.delay)
{
SLEEP (tx.delay);
if ( (verbose) && (!src_random) && (!dst_random) )
{
fprintf(stderr, ".");
}
}
} // end for
} // end while
if (verbose)
{
if ((tx.delay) || (tx.count==0))
{
fprintf(stderr,"\n");
}
fprintf(stderr, " mz: sent %u frames.\n",loop);
}
libnet_destroy(l);
return 0;
}
int application_start(void)
{
OSStatus err = kNoErr;
IPStatusTypedef para;
struct tm currentTime;
mico_rtc_time_t time;
char wifi_ver[64] = {0};
mico_log_trace();
/*Read current configurations*/
context = ( mico_Context_t *)malloc(sizeof(mico_Context_t) );
require_action( context, exit, err = kNoMemoryErr );
memset(context, 0x0, sizeof(mico_Context_t));
mico_rtos_init_mutex(&context->flashContentInRam_mutex);//ram互斥初始化
mico_rtos_init_semaphore(&context->micoStatus.sys_state_change_sem, 1);//系统状态信号量
mico_rtos_create_thread( NULL, MICO_APPLICATION_PRIORITY, "sys", _sys_state_thread, 800, NULL );
MICOReadConfiguration( context );//读flash数据
err = MICOInitNotificationCenter ( context );
err = MICOAddNotification( mico_notify_READ_APP_INFO, (void *)micoNotify_ReadAppInfoHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WIFI_CONNECT_FAILED, (void *)micoNotify_ConnectFailedHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_WIFI_Fatal_ERROR, (void *)micoNotify_WlanFatalErrHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_Stack_Overflow_ERROR, (void *)micoNotify_StackOverflowErrHandler );
require_noerr( err, exit );
/*wlan driver and tcpip init*/
mico_log( "MiCO starting..." );
MicoInit();
#ifdef MICO_CLI_ENABLE
MicoCliInit();
#endif
MicoSysLed(true);
mico_log("Free memory %d bytes", MicoGetMemoryInfo()->free_memory);
micoWlanGetIPStatus(¶, Station);
formatMACAddr(context->micoStatus.mac, (char *)para.mac);
MicoGetRfVer(wifi_ver, sizeof(wifi_ver));
mico_log("ip = %s,mac=%s",para.ip,para.mac);
mico_log("%s mxchipWNet library version: %s", APP_INFO, MicoGetVer());
mico_log("Wi-Fi driver version %s, mac %s", wifi_ver, context->micoStatus.mac);
/*Start system monotor thread*/
//err = MICOStartSystemMonitor(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the system monitor.") );
err = MICORegisterSystemMonitor(&mico_monitor, APPLICATION_WATCHDOG_TIMEOUT_SECONDS*1000);
require_noerr( err, exit );
mico_init_timer(&_watchdog_reload_timer,APPLICATION_WATCHDOG_TIMEOUT_SECONDS*1000/2, _watchdog_reload_timer_handler, NULL);
mico_start_timer(&_watchdog_reload_timer);
/* Enter test mode, call a build-in test function amd output on MFG UART */
if(MicoShouldEnterMFGMode()==true){
mico_log( "Enter MFG mode by MFG button" );
mico_mfg_test(context);
}
/*Read current time from RTC.*/
if( MicoRtcGetTime(&time) == kNoErr ){
currentTime.tm_sec = time.sec;
currentTime.tm_min = time.min;
currentTime.tm_hour = time.hr;
currentTime.tm_mday = time.date;
currentTime.tm_wday = time.weekday;
currentTime.tm_mon = time.month - 1;
currentTime.tm_year = time.year + 100;
mico_log("Current Time: %s",asctime(¤tTime));
}else
mico_log("RTC function unsupported");
/* Regisist notifications */
err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)micoNotify_WifiStatusHandler );
require_noerr( err, exit );
if( context->flashContentInRam.micoSystemConfig.configured == wLanUnConfigured ||
context->flashContentInRam.micoSystemConfig.configured == unConfigured){
mico_log("Empty configuration. Starting configuration mode...");
//HERE TO config network
#if (MICO_CONFIG_MODE == CONFIG_MODE_EASYLINK) || (MICO_CONFIG_MODE == CONFIG_MODE_EASYLINK_WITH_SOFTAP)
err = startEasyLink( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_SOFT_AP)
err = startEasyLinkSoftAP( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_AIRKISS)
err = startAirkiss( context );
require_noerr( err, exit );
#elif (MICO_CONFIG_MODE == CONFIG_MODE_WPS) || MICO_CONFIG_MODE == defined (CONFIG_MODE_WPS_WITH_SOFTAP)
err = startWPS( context );
require_noerr( err, exit );
#elif ( MICO_CONFIG_MODE == CONFIG_MODE_WAC)
WACPlatformParameters_t* WAC_Params = NULL;
WAC_Params = calloc(1, sizeof(WACPlatformParameters_t));
require(WAC_Params, exit);
str2hex((unsigned char *)para.mac, WAC_Params->macAddress, 6);
WAC_Params->isUnconfigured = 1;
WAC_Params->supportsAirPlay = 0;
WAC_Params->supportsAirPrint = 0;
WAC_Params->supports2_4GHzWiFi = 1;
WAC_Params->supports5GHzWiFi = 0;
WAC_Params->supportsWakeOnWireless = 0;
WAC_Params->firmwareRevision = FIRMWARE_REVISION;
WAC_Params->hardwareRevision = HARDWARE_REVISION;
WAC_Params->serialNumber = SERIAL_NUMBER;
WAC_Params->name = context->flashContentInRam.micoSystemConfig.name;
WAC_Params->model = MODEL;
WAC_Params->manufacturer = MANUFACTURER;
WAC_Params->numEAProtocols = 1;
WAC_Params->eaBundleSeedID = BUNDLE_SEED_ID;
WAC_Params->eaProtocols = (char **)eaProtocols;
err = startMFiWAC( context, WAC_Params, MICO_I2C_CP, 1200 );
free(WAC_Params);
require_noerr( err, exit );
#else
#error "Wi-Fi configuration mode is not defined"
#endif
}
else{
mico_log("Available configuration. Starting Wi-Fi connection...");
_ConnectToAP( context );
}
#ifdef MFG_MODE_AUTO
if( context->flashContentInRam.micoSystemConfig.configured == mfgConfigured ){
mico_log( "Enter MFG mode automatically" );
mico_mfg_test(context);
mico_thread_sleep(MICO_NEVER_TIMEOUT);
}
#endif
err = MICOAddNotification( mico_notify_WiFI_PARA_CHANGED, (void *)micoNotify_WiFIParaChangedHandler );
require_noerr( err, exit );
err = MICOAddNotification( mico_notify_DHCP_COMPLETED, (void *)micoNotify_DHCPCompleteHandler );
require_noerr( err, exit );
if(context->flashContentInRam.micoSystemConfig.rfPowerSaveEnable == true){
micoWlanEnablePowerSave();
}
if(context->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable == true){
MicoMcuPowerSaveConfig(true);
}
/*Local configuration server*/
if(context->flashContentInRam.micoSystemConfig.configServerEnable == true){
err = MICOStartConfigServer(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the local server thread.") );
}
err = MICOStartNTPClient(context);
require_noerr_action( err, exit, mico_log("ERROR: Unable to start the NTP client thread.") );
/*Start mico application*/
err = MICOStartApplication( context );
require_noerr( err, exit );
mico_log("Free memory %d bytes", MicoGetMemoryInfo()->free_memory) ;
require_noerr_action( err, exit, mico_log("Closing main thread with err num: %d.", err) );
exit:
mico_rtos_delete_thread(NULL);
return kNoErr;
}
int main(int argc, char *argv[])
{
char *line = NULL;
int len = 0, num = 0, n, rlen, type;
unsigned char am, al, checksum;
unsigned int addr;
int flash_size = 0;
int ch, option_index;
static struct option long_options[] = {
{"flash-size", 1, 0, 'S'},
{"help", 0, 0, 'h'},
{"version", 0, 0, 'v'},
{ 0, 0, 0, 0 }
};
unsigned char *ptr;
int ret;
/* Process command line arguments */
while (1) {
ch = getopt_long(argc, argv, "S:hv",
long_options, &option_index);
if (ch == -1)
break;
switch (ch) {
case 'S' : /* flash-size */
ret = sscanf(optarg, "%d", &flash_size);
if (ret !=1) {
PERR("set-control: Invalid value");
exit(EXIT_FAILURE);
}
break;
case 'h' : /* help */
print_help();
exit(EXIT_SUCCESS);
break;
case 'v' : /* version */
print_version();
exit(EXIT_SUCCESS);
break;
default :
print_help();
exit(EXIT_FAILURE);
}
}
/* Sanity checks */
if (flash_size == 0) {
PERR("flash size unknow");
exit(EXIT_FAILURE);
}
/* Build the flash image */
ptr = (unsigned char *) malloc(flash_size);
if (!ptr) {
PERR("unable to allocate memory for flash image");
exit(EXIT_FAILURE);
}
memset(ptr, 0xff, flash_size);
/* Do the job */
while (1) {
/* Read ASCII strings from stdin */
n = getline(&line, &len, stdin);
if (n < 0) {
if (feof(stdin))
break; /* EOF */
PERR("error reading input data file");
return -1;
}
n = strlen(line)-1;
if (n >= 0)
line[n] = '\0';
num++;
PDEBUG("[%05d]> %s", num, line);
if (line[0] != ':') {
PDEBUG("no data line, skipped");
continue;
}
rlen = str2hex(line[1], line[2]);
if (rlen > 16) {
PERR("record too long at line %d", num);
return -1;
}
am = str2hex(line[3], line[4]);
al = str2hex(line[5], line[6]);
addr = (am<<8)+al;
if (addr >= flash_size) {
PERR("invalid addres \"%x\"", addr);
exit(EXIT_FAILURE);
}
type = str2hex(line[7], line[8]);
checksum = str2hex(line[9+rlen*2], line[10+rlen*2]);
PDEBUG("len %d - addr %04x - type %s - checksum %02x",
rlen, addr, type == 0 ? "data" : "end", checksum);
if (type == 1) {
PDEBUG("end");
break;
}
/* Save the data */
for (n = 0; n < rlen; n++)
ptr[addr+n] = str2hex(line[9+n*2], line[10+n*2]);
#if 0
/* FIXME: should check checksum??? */
checksum = compute_checksum(&wbuf[2], rlen+5);
#endif
#ifndef DEBUG
fprintf(stderr, ".");
fflush(stdout);
#endif
}
#ifndef DEBUG
fprintf(stderr, "\n");
#endif
/* Write the flash image to the stdout */
ret = fwrite(ptr, flash_size, 1, stdout);
if (ret < 0) {
PERR("cannot write flash image");
return -1;
}
return 0;
}
/* Print to stdout detailed session summary */
hash_stat print_session_detailed(char *sessionname)
{
#ifdef HAVE_JSON_JSON_H
FILE *sesfile;
struct passwd *pwd;
char sesname[1024];
int cnt=0;
char username[HASHFILE_MAX_LINE_LENGTH];
char hash[HASHFILE_MAX_LINE_LENGTH];
char rawhash[HASHFILE_MAX_LINE_LENGTH];
char rawhash2[HASHFILE_MAX_LINE_LENGTH*2];
char plugin_used[HASHFILE_MAX_LINE_LENGTH*2];
char salt[HASHFILE_MAX_LINE_LENGTH];
int flag = 0;
json_object *jobj;
printf("\nDetailed information about session: %s\n"
"-----------------------------------------------\n",sessionname);
pwd = getpwuid(getuid());
snprintf(sesname, 1024, "%s/.hashkill/sessions/%s.session", pwd->pw_dir, sessionname);
/* Parse the <session>..</session> info */
sesfile = fopen(sesname, "r");
if (!sesfile)
{
elog("Cannot open session file : %s\n",sesname);
return hash_err;
}
printf("Session file: \t%s\n",sesname);
fclose(sesfile);
root_node = json_object_from_file(sesname);
main_header_node = json_object_object_get(root_node,"main");
switch (json_object_get_int(json_object_object_get(main_header_node,"attacktype")))
{
case attack_method_simple_bruteforce:
printf("Attack type: \tBruteforce\n");
break;
case attack_method_markov:
printf("Attack type: \tMarkov\n");
break;
case attack_method_rule:
printf("Attack type: \tRule-based\n");
break;
default:
printf("Attack type: \tUNKNOWN!\n");
break;
}
attack_method=json_object_get_int(json_object_object_get(main_header_node,"attacktype"));
printf("Plugin: \t%s\n",json_object_get_string(json_object_object_get(main_header_node,"plugin")));
printf("Progress: \t%d%%\n",json_object_get_int(json_object_object_get(main_header_node,"progress")));
printf("Session ends: \t%s",json_object_get_string(json_object_object_get(main_header_node,"timestamp")));
printf("Hashlist file: \t%s\n",json_object_get_string(json_object_object_get(main_header_node,"hashlistfile")));
printf("Command line: \t%s\n",json_object_get_string(json_object_object_get(main_header_node,"commandline")));
switch (attack_method)
{
case attack_method_simple_bruteforce:
attack_header_node = json_object_object_get(root_node,"bruteforce");
printf("\nBruteforce attack parameters:\n"
"-----------------------------\n");
printf("Start length: \t%d\n",json_object_get_int(json_object_object_get(attack_header_node,"start")));
printf("End length: \t%d\n",json_object_get_int(json_object_object_get(attack_header_node,"end")));
printf("Charset: \t%s\n",json_object_get_string(json_object_object_get(attack_header_node,"charset")));
printf("Current str: \t%s\n",json_object_get_string(json_object_object_get(attack_header_node,"currentstr")));
break;
case attack_method_markov:
attack_header_node = json_object_object_get(root_node,"markov");
printf("\nMarkov attack parameters:\n"
"-------------------------\n");
printf("Statfile: \t%s\n",json_object_get_string(json_object_object_get(attack_header_node,"statfile")));
printf("Threshold: \t%d\n",json_object_get_int(json_object_object_get(attack_header_node,"threshold")));
printf("End length: \t%d\n",json_object_get_int(json_object_object_get(attack_header_node,"maxlen")));
printf("Current str: \t%s\n",json_object_get_string(json_object_object_get(attack_header_node,"currentstr")));
break;
case attack_method_rule:
attack_header_node = json_object_object_get(root_node,"rule");
printf("\nRule attack parameters:\n"
"-----------------------\n");
printf("Rule file: \t%s\n",json_object_get_string(json_object_object_get(attack_header_node,"rulefile")));
break;
}
printf("\nHashes list (username:hash:salt):\n---------------------------------\n");
hash_list_node = json_object_object_get(root_node,"hashlist");
flag = json_object_array_length(hash_list_node);
for (cnt=0;cnt<flag;cnt++)
{
jobj = json_object_array_get_idx(hash_list_node, cnt);
strcpy(username, json_object_get_string(json_object_object_get(jobj,"username")));
strcpy(hash, json_object_get_string(json_object_object_get(jobj,"hash")));
strcpy(salt, json_object_get_string(json_object_object_get(jobj,"salt")));
// This is idiotic I know
if ((strncmp(plugin_used,"md5unix",8)==0) || (strncmp(plugin_used,"sha512unix",10)==0) ||(strncmp(plugin_used,"phpbb3",6)==0) || (strncmp(plugin_used,"wordpress",9)==0) || (strncmp(plugin_used,"apr1",4)==0))
{
b64_pton(hash,(unsigned char *)rawhash,512);
printf("%s:%s%s\n", username, salt, rawhash);
}
else if ( (strncmp(plugin_used,"desunix",7)==0)
|| (strncmp(plugin_used,"ldap-sha",8)==0) || (strncmp(plugin_used,"ldap-ssha",9)==0))
{
b64_pton(hash,(unsigned char *)rawhash,512);
printf("%s:%s:%s\n", username, rawhash, salt);
}
else
{
str2hex(rawhash,rawhash2, (strlen(hash)*100)/147);
printf("%s:%s:%s\n", username, rawhash2, salt);
}
}
cracked_list_node = json_object_object_get(root_node,"crackedlist");
if (cracked_list_node)
{
cnt = json_object_array_length(cracked_list_node);
}
else
{
cnt=0;
}
printf("\n%d passwords cracked.\n",cnt);
printf("\n");
hlog("Session %s dumped successfully\n\n", sessionname);
return hash_ok;
#else
wlog("This build does not support sessions. Please reconfigure with --with-json and rebuild%s\n","");
return hash_err;
#endif
}
