void fill_link_header(uint8* buf, int8 pdu_type, uint16 frag_len, uint16 msg_seq) {
void* buf_ptr = buf;
uint8 dest_mac[6] = {0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
uint8 src_mac[6] = {0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa};
set_mac(dest_mac, buf_ptr);
buf_ptr += 6;
set_mac(src_mac, buf_ptr);
buf_ptr += 6;
*((uint16*)buf_ptr) = ETH_P_MSG;
buf_ptr += 2;
static uint16 frag_seq = 0;
link_header_t* lh = (link_header_t*)buf_ptr;
lh->frag_index = 0;
lh->frag_seq = frag_seq;
lh->is_last_frag = 1;
lh->msg_seq = msg_seq;
lh->frag_len = frag_len;
lh->pdu_type = pdu_type;
lh->src_node = 1;
lh->dst_node = 0;
}
/* Populates globule->mac with the MAC address of the interface globule->iface */
int read_iface_mac()
{
struct ifreq ifr;
struct ether_addr *eth = NULL;
int sock = 0, ret_val = 0;
/* Need a socket for the ioctl call */
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
if(sock != -1)
{
eth = malloc(sizeof(struct ether_addr));
if(eth)
{
memset(eth, 0, sizeof(struct ether_addr));
/* Prepare request */
memset(&ifr, 0, sizeof(struct ifreq));
strncpy(ifr.ifr_name, get_iface(), IFNAMSIZ);
/* Do it */
if(ioctl(sock, SIOCGIFHWADDR, &ifr) == 0)
{
set_mac((unsigned char *) &ifr.ifr_hwaddr.sa_data);
ret_val = 1;
}
free(eth);
}
close(sock);
}
return ret_val;
}
device_network_interface::device_network_interface(const machine_config &mconfig, device_t &device, float bandwidth)
: device_interface(device, "network")
{
m_promisc = false;
m_bandwidth = bandwidth;
set_mac("\0\0\0\0\0\0");
m_intf = 0;
}
void ethernet_initialize(uint8_t mac[6])
{
//Conf the LEDs
write_phy(PHLCON, 0b0011110000010011);
//Configure some buffers and MAC stuff for half duplex
//Recieve buffer spans 0x0000 to 0x0FFF
switch_bank(0);
spi_transaction(WRITE_CONTROL_REGISTER, ERXSTL, 0x00);
spi_transaction(WRITE_CONTROL_REGISTER, ERXSTH, 0x00);
spi_transaction(WRITE_CONTROL_REGISTER, ERXNDL, 0xFF);
spi_transaction(WRITE_CONTROL_REGISTER, ERXNDH, 0x0F);
spi_transaction(WRITE_CONTROL_REGISTER, ERXRDPTL, 0x00);
spi_transaction(WRITE_CONTROL_REGISTER, ERXRDPTH, 0x00);
//Transmit buffers covers 0x1000 to 0x1FFF
//...
uint8_t reg;
do {
reg = spi_transaction(READ_CONTROL_REGISTER, ESTAT, 0);
} while(!(reg & (1<<CLKRDY)));
//MAC settings
switch_bank(2);
spi_transaction(WRITE_CONTROL_REGISTER, MACON1, (1<<MARXEN));
spi_transaction(WRITE_CONTROL_REGISTER, MACON3, 0b11110000);
spi_transaction(WRITE_CONTROL_REGISTER, MACON4, 0b01000000); //DEFER
//1518 bytes
spi_transaction(WRITE_CONTROL_REGISTER, MAMXFLL, 0xEE);
spi_transaction(WRITE_CONTROL_REGISTER, MAMXFLH, 0x05);
spi_transaction(WRITE_CONTROL_REGISTER, MABBIPG, 0x12);
spi_transaction(WRITE_CONTROL_REGISTER, MAIPGL, 0x12);
spi_transaction(WRITE_CONTROL_REGISTER, MAIPGH, 0x0C);
set_mac(mac);
write_phy(PHCON2, (1<<HDLDIS));
write_phy(PHCON1, 0);
//Enable reception
spi_transaction(BIT_FIELD_SET, ECON1, (1<<RXEN));
puts("Enabled reception");
}
void MirSurface::raise_surface_with_cookie(MirCookie const& cookie)
{
mp::RaiseRequest raise_request;
std::unique_lock<decltype(mutex)> lock(mutex);
raise_request.mutable_surface_id()->set_value(surface->id().value());
auto const event_cookie = raise_request.mutable_cookie();
event_cookie->set_timestamp(cookie.timestamp);
event_cookie->set_mac(cookie.mac);
server->raise_surface_with_cookie(
&raise_request,
void_response.get(),
google::protobuf::NewCallback(google::protobuf::DoNothing));
}
/* retval = bytes sent */
int sendpacket(char *dst_mac, const void *buf, int len) {
int sock;
struct sockaddr_ll s_ll;
struct ifreq ifr;
int tolen;
int n;
bzero((void *) &s_ll,sizeof(struct sockaddr_ll));
s_ll.sll_family = AF_PACKET;
s_ll.sll_halen = ETH_ALEN;
s_ll.sll_protocol = htons(ETH_P_IPV6);
s_ll.sll_hatype = 0;
s_ll.sll_pkttype = 0;
set_mac(dst_mac, &s_ll.sll_addr[0]); /* 00:A0:C9:DB:A7:FD=gaijin */
sock = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IPV6));
if(sock < 0) {
perror("got r00t ? Raw socket");
exit(EACCES);
}
/* fixed ethdevice, kludge */
strncpy((char *) &ifr.ifr_name, "eth0", IFNAMSIZ);
if (ioctl(sock, SIOCGIFINDEX, &ifr) < 0) {
perror("ioctl SIOCGIFINDEX");
close(sock);
exit(1);
}
s_ll.sll_ifindex = ifr.ifr_ifindex;
tolen = sizeof(struct sockaddr_ll);
n = sendto(sock, buf, len, 0, (struct sockaddr *) &s_ll, tolen);
if (n>0) {
fprintf(stderr, "sp: sendto: n=%d\n", n);
} else {
fprintf(stderr, "sp: error: n<0\n");
}
close(sock);
return(n);
}
//----------------------------------------------------------------------------------
static int secure_cmd_burn_mac(char *pSRC, int nDataLen, char *pOUT, int *pOUTLen)
{
int ret = -1;
if((nDataLen!= 6) || (NULL == pSRC))
return ret;
char out[128];
int outlen = 128;
memset(out, 0, 128);
memcpy(out, pSRC, 6);
ret = set_mac(out, FROM_KERNEL);
#ifdef SECURE_EFUSE_DEBUG
efuse_debug_get(53, 7, pOUT);
#endif
return ret;
}
netdev_pcap::netdev_pcap(const char *name, class device_network_interface *ifdev, int rate)
: netdev(ifdev, rate)
{
char errbuf[PCAP_ERRBUF_SIZE];
m_p = pcap_open_live_dl(name, 65535, 1, 1, errbuf);
if(!m_p)
{
logerror("Unable to open %s: %s\n", name, errbuf);
return;
}
if(pcap_set_datalink_dl(m_p, DLT_EN10MB) == -1)
{
logerror("Unable to set %s to ethernet", name);
pcap_close_dl(m_p);
m_p = NULL;
return;
}
set_mac(get_mac());
}
int read_iface_mac() {
struct ifaddrs* iflist;
int found = 0;
if (getifaddrs(&iflist) == 0) {
struct ifaddrs* cur;
for (cur = iflist; cur; cur = cur->ifa_next) {
if ((cur->ifa_addr->sa_family == AF_LINK) &&
(strcmp(cur->ifa_name, get_iface()) == 0) &&
cur->ifa_addr) {
struct sockaddr_dl* sdl = (struct sockaddr_dl*)cur->ifa_addr;
set_mac(LLADDR(sdl));
found = 1;
break;
}
}
freeifaddrs(iflist);
}
return found;
}
bool CMonster::ReplaceSoul(const MonsterInfo &info, bool boss)
{
bBoss = boss;
id = info.ID;
name = info.name;
set_head(info.Head);
set_Lv(info.level);
set_exp(info.exp);
set_hp_m(info.hp);
set_mp_m(info.mp);
set_dc(info.DC1, info.DC2);
set_mc(info.MC1, info.MC2);
set_sc(0, 0);
set_ac(info.AC, info.AC);
set_mac(info.MAC, info.MAC);
set_intervel(info.interval);
QString str[10] = { QStringLiteral("ÆË»÷"), QStringLiteral("³åײ"), QStringLiteral("¿ÖÏÅ"), QStringLiteral("·É»÷"), QStringLiteral("Ó°»÷"),
QStringLiteral("¶¾Êõ"), QStringLiteral("´ÎÉù²¨"), QStringLiteral("¼«ËÙ"), QStringLiteral("¾ÞÁ¦"), QStringLiteral("¼ṳ̀") };
skill.name = str[qrand() % 10];
return true;
}
int eeprom(int argc, char * const argv[])
{
int i, len, ret;
unsigned char buf[58], *p;
app_startup(argv);
i = get_version();
if (i != XF_VERSION) {
printf("Using ABI version %d, but U-Boot provides %d\n",
XF_VERSION, i);
return 1;
}
if ((SMC_inw(&dev, BANK_SELECT) & 0xFF00) != 0x3300) {
puts("SMSC91111 not found\n");
return 2;
}
/* Called without parameters - print MAC address */
if (argc < 2) {
verify_macaddr(NULL);
return 0;
}
/* Print help message */
if (argv[1][1] == 'h') {
puts("NetStar EEPROM writer\n"
"Built: " U_BOOT_DATE " at " U_BOOT_TIME "\n"
"Usage:\n\t<mac_address> [<element_1>] [<...>]\n");
return 0;
}
/* Try to parse information elements */
len = sizeof(buf);
p = buf;
for (i = 2; i < argc; i++) {
ret = parse_element(argv[i], p, len);
switch (ret) {
case -1:
printf("Element %d: malformed\n", i - 1);
return 3;
case -2:
printf("Element %d: odd character count\n", i - 1);
return 3;
case -3:
puts("Out of EEPROM memory\n");
return 3;
default:
p += ret;
len -= ret;
}
}
/* First argument (MAC) is mandatory */
set_mac(argv[1]);
if (verify_macaddr(argv[1])) {
puts("*** HWaddr does not match! ***\n");
return 4;
}
while (len--)
*p++ = 0;
write_data((u16 *)buf, sizeof(buf) >> 1);
return 0;
}
/* Processes Reaver command line options */
int process_arguments(int argc, char **argv)
{
int ret_val = EXIT_SUCCESS;
int c = 0, channel = 0;
int long_opt_index = 0;
char bssid[MAC_ADDR_LEN] = { 0 };
char mac[MAC_ADDR_LEN] = { 0 };
char *short_options = "b:e:m:i:t:d:c:T:x:r:g:l:o:p:s:C:KZA5ELfnqvDShwN6J";
struct option long_options[] = {
{ "pixie-dust", no_argument, NULL, 'K' },
{ "interface", required_argument, NULL, 'i' },
{ "bssid", required_argument, NULL, 'b' },
{ "essid", required_argument, NULL, 'e' },
{ "mac", required_argument, NULL, 'm' },
{ "timeout", required_argument, NULL, 't' },
{ "m57-timeout", required_argument, NULL, 'T' },
{ "delay", required_argument, NULL, 'd' },
{ "lock-delay", required_argument, NULL, 'l' },
{ "fail-wait", required_argument, NULL, 'x' },
{ "channel", required_argument, NULL, 'c' },
{ "session", required_argument, NULL, 's' },
{ "recurring-delay", required_argument, NULL, 'r' },
{ "max-attempts", required_argument, NULL, 'g' },
{ "out-file", required_argument, NULL, 'o' },
{ "pin", required_argument, NULL, 'p' },
{ "exec", required_argument, NULL, 'C' },
{ "no-associate", no_argument, NULL, 'A' },
{ "ignore-locks", no_argument, NULL, 'L' },
{ "no-nacks", no_argument, NULL, 'N' },
{ "eap-terminate", no_argument, NULL, 'E' },
{ "dh-small", no_argument, NULL, 'S' },
{ "fixed", no_argument, NULL, 'f' },
{ "daemonize", no_argument, NULL, 'D' },
{ "5ghz", no_argument, NULL, '5' },
{ "repeat-m6", no_argument, NULL, '6' },
{ "nack", no_argument, NULL, 'n' },
{ "quiet", no_argument, NULL, 'q' },
{ "verbose", no_argument, NULL, 'v' },
{ "win7", no_argument, NULL, 'w' },
{ "help", no_argument, NULL, 'h' },
{ "timeout-is-nack", no_argument, NULL, 'J' },
{ 0, 0, 0, 0 }
};
/* Since this function may be called multiple times, be sure to set opt index to 0 each time */
optind = 0;
while((c = getopt_long(argc, argv, short_options, long_options, &long_opt_index)) != -1)
{
switch(c)
{
case 'Z':
case 'K':
pixie.do_pixie = 1;
break;
case 'i':
set_iface(optarg);
break;
case 'b':
str2mac(optarg, (unsigned char *) &bssid);
set_bssid((unsigned char *) &bssid);
break;
case 'e':
set_ssid(optarg);
break;
case 'm':
str2mac(optarg, (unsigned char *) &mac);
set_mac((unsigned char *) &mac);
break;
case 't':
set_rx_timeout(atoi(optarg));
break;
case 'T':
set_m57_timeout(strtof(optarg, NULL) * SEC_TO_US);
break;
case 'c':
channel = strtod(optarg, NULL);
set_fixed_channel(1);
break;
case '5':
set_wifi_band(AN_BAND);
break;
case '6':
set_repeat_m6(1);
break;
case 'd':
set_delay(atoi(optarg));
break;
case 'l':
set_lock_delay(atoi(optarg));
break;
case 'p':
parse_static_pin(optarg);
break;
case 's':
set_session(optarg);
break;
case 'C':
set_exec_string(optarg);
break;
case 'A':
set_external_association(1);
break;
case 'L':
set_ignore_locks(1);
break;
case 'o':
set_log_file(fopen(optarg, "w"));
break;
case 'x':
set_fail_delay(atoi(optarg));
break;
case 'r':
parse_recurring_delay(optarg);
break;
case 'g':
set_max_pin_attempts(atoi(optarg));
break;
case 'D':
daemonize();
break;
case 'E':
set_eap_terminate(1);
break;
case 'S':
set_dh_small(1);
break;
case 'n':
cprintf(INFO, "[+] ignoring obsolete -n switch\n");
break;
case 'J':
set_timeout_is_nack(1);
break;
case 'f':
set_fixed_channel(1);
break;
case 'v':
set_debug(get_debug() + 1);
break;
case 'q':
set_debug(CRITICAL);
break;
case 'w':
set_win7_compat(1);
break;
case 'N':
set_oo_send_nack(0);
break;
default:
ret_val = EXIT_FAILURE;
}
}
if(channel)
{
change_channel(channel);
}
return ret_val;
}
/* Brute force all possible WPS pins for a given access point */
void crack()
{
unsigned char *bssid = NULL;
char *pin = NULL;
int fail_count = 0, loop_count = 0, sleep_count = 0, assoc_fail_count = 0;
float pin_count = 0;
time_t start_time = 0;
enum wps_result result = 0;
/* MAC CHANGER VARIABLES */
int mac_changer_counter = 0;
char mac[MAC_ADDR_LEN] = { 0 };
unsigned char mac_string [] = "ZZ:ZZ:ZZ:ZZ:ZZ:ZZ";
unsigned char* new_mac = &mac_string[0];
char last_digit = '0';
if(!get_iface())
{
return;
}
if(get_max_pin_attempts() == -1)
{
cprintf(CRITICAL, "[X] ERROR: This device has been blacklisted and is not supported.\n");
return;
}
/* Initialize network interface */
set_handle(capture_init(get_iface()));
if(get_handle() != NULL)
{
generate_pins();
/* Restore any previously saved session */
if(get_static_p1() == NULL)
{
restore_session();
}
/* Convert BSSID to a string */
bssid = mac2str(get_bssid(), ':');
/*
* We need to get some basic info from the AP, and also want to make sure the target AP
* actually exists, so wait for a beacon packet
*/
cprintf(INFO, "[+] Waiting for beacon from %s\n", bssid);
read_ap_beacon();
process_auto_options();
/* I'm fairly certian there's a reason I put this in twice. Can't remember what it was now though... */
if(get_max_pin_attempts() == -1)
{
cprintf(CRITICAL, "[X] ERROR: This device has been blacklisted and is not supported.\n");
return;
}
/* This initial association is just to make sure we can successfully associate */
while(!reassociate())
{
if(assoc_fail_count == MAX_ASSOC_FAILURES)
{
assoc_fail_count = 0;
cprintf(CRITICAL, "[!] WARNING: Failed to associate with %s (ESSID: %s)\n", bssid, get_ssid());
}
else
{
assoc_fail_count++;
}
}
cprintf(INFO, "[+] Associated with %s (ESSID: %s)\n", bssid, get_ssid());
/* Used to calculate pin attempt rates */
start_time = time(NULL);
/* If the key status hasn't been explicitly set by restore_session(), ensure that it is set to KEY1_WIP */
if(get_key_status() <= KEY1_WIP)
{
set_key_status(KEY1_WIP);
}
/*
* If we're starting a session at KEY_DONE, that means we've already cracked the pin and the AP is being re-attacked.
* Re-set the status to KEY2_WIP so that we properly enter the main cracking loop.
*/
else if(get_key_status() == KEY_DONE)
{
set_key_status(KEY2_WIP);
}
//copy the current mac to the new_mac variable for mac changer
if (get_mac_changer() == 1) {
strncpy(new_mac, mac2str(get_mac(), ':'), 16);
}
/* Main cracking loop */
for(loop_count=0, sleep_count=0; get_key_status() != KEY_DONE; loop_count++, sleep_count++)
{
//MAC Changer switch/case to define the last mac address digit
if (get_mac_changer() == 1) {
switch (mac_changer_counter) {
case 0:
last_digit = '0';
break;
case 1:
last_digit = '1';
break;
case 2:
last_digit = '2';
break;
case 3:
last_digit = '3';
break;
case 4:
last_digit = '4';
break;
case 5:
last_digit = '5';
break;
case 6:
last_digit = '6';
break;
case 7:
last_digit = '7';
break;
case 8:
last_digit = '8';
break;
case 9:
last_digit = '9';
break;
case 10:
last_digit = 'A';
break;
case 11:
last_digit = 'B';
break;
case 12:
last_digit = 'C';
break;
case 13:
last_digit = 'D';
break;
case 14:
last_digit = 'E';
break;
case 15:
last_digit = 'F';
mac_changer_counter = -1;
break;
}
mac_changer_counter++;
new_mac[16] = last_digit;
//transform the string to a MAC and define the MAC
str2mac((unsigned char *) new_mac, (unsigned char *) &mac);
set_mac((unsigned char *) &mac);
cprintf(WARNING, "[+] Using MAC %s \n", mac2str(get_mac(), ':'));
}
/*
* Some APs may do brute force detection, or might not be able to handle an onslaught of WPS
* registrar requests. Using a delay here can help prevent the AP from locking us out.
*/
pcap_sleep(get_delay());
/* Users may specify a delay after x number of attempts */
if((get_recurring_delay() > 0) && (sleep_count == get_recurring_delay_count()))
{
cprintf(VERBOSE, "[+] Entering recurring delay of %d seconds\n", get_recurring_delay());
pcap_sleep(get_recurring_delay());
sleep_count = 0;
}
/*
* Some APs identify brute force attempts and lock themselves for a short period of time (typically 5 minutes).
* Verify that the AP is not locked before attempting the next pin.
*/
while(get_ignore_locks() == 0 && is_wps_locked())
{
cprintf(WARNING, "[!] WARNING: Detected AP rate limiting, waiting %d seconds before re-checking\n", get_lock_delay());
pcap_sleep(get_lock_delay());
}
/* Initialize wps structure */
set_wps(initialize_wps_data());
if(!get_wps())
{
cprintf(CRITICAL, "[-] Failed to initialize critical data structure\n");
break;
}
/* Try the next pin in the list */
pin = build_next_pin();
if(!pin)
{
cprintf(CRITICAL, "[-] Failed to generate the next payload\n");
break;
}
else
{
cprintf(WARNING, "[+] Trying pin %s\n", pin);
}
/*
* Reassociate with the AP before each WPS exchange. This is necessary as some APs will
* severely limit our pin attempt rate if we do not.
*/
assoc_fail_count = 0;
while(!reassociate())
{
if(assoc_fail_count == MAX_ASSOC_FAILURES)
{
assoc_fail_count = 0;
cprintf(CRITICAL, "[!] WARNING: Failed to associate with %s (ESSID: %s)\n", bssid, get_ssid());
}
else
{
assoc_fail_count++;
}
}
/*
* Enter receive loop. This will block until a receive timeout occurs or a
* WPS transaction has completed or failed.
*/
result = do_wps_exchange();
switch(result)
{
/*
* If the last pin attempt was rejected, increment
* the pin counter, clear the fail counter and move
* on to the next pin.
*/
case KEY_REJECTED:
fail_count = 0;
pin_count++;
advance_pin_count();
break;
/* Got it!! */
case KEY_ACCEPTED:
break;
/* Unexpected timeout or EAP failure...try this pin again */
default:
cprintf(VERBOSE, "[!] WPS transaction failed (code: 0x%.2X), re-trying last pin\n", result);
fail_count++;
break;
}
/* If we've had an excessive number of message failures in a row, print a warning */
if(fail_count == WARN_FAILURE_COUNT)
{
cprintf(WARNING, "[!] WARNING: %d failed connections in a row\n", fail_count);
fail_count = 0;
pcap_sleep(get_fail_delay());
}
/* Display status and save current session state every DISPLAY_PIN_COUNT loops */
if(loop_count == DISPLAY_PIN_COUNT)
{
save_session();
display_status(pin_count, start_time);
loop_count = 0;
}
/*
* The WPA key and other settings are stored in the globule->wps structure. If we've
* recovered the WPS pin and parsed these settings, don't free this structure. It
* will be freed by wpscrack_free() at the end of main().
*/
if(get_key_status() != KEY_DONE)
{
wps_deinit(get_wps());
set_wps(NULL);
}
/* If we have cracked the pin, save a copy */
else
{
set_pin(pin);
}
free(pin);
pin = NULL;
/* If we've hit our max number of pin attempts, quit */
if((get_max_pin_attempts() > 0) &&
(pin_count == get_max_pin_attempts()))
{
cprintf(VERBOSE, "[+] Quitting after %d crack attempts\n", get_max_pin_attempts());
break;
}
}
if(bssid) free(bssid);
if(get_handle())
{
pcap_close(get_handle());
set_handle(NULL);
}
}
else
{
cprintf(CRITICAL, "[-] Failed to initialize interface '%s'\n", get_iface());
}
}
int eeprom(int argc, char *argv[])
{
int i, len, ret;
unsigned char buf[58], *p;
struct eth_device dev = {
.iobase = CONFIG_SMC91111_BASE
};
app_startup(argv);
if (get_version() != XF_VERSION) {
printf("Wrong XF_VERSION.\n");
printf("Application expects ABI version %d\n", XF_VERSION);
printf("Actual U-Boot ABI version %d\n", (int)get_version());
return 1;
}
return crcek();
if ((SMC_inw (&dev, BANK_SELECT) & 0xFF00) != 0x3300) {
printf("SMSC91111 not found.\n");
return 2;
}
/* Called without parameters - print MAC address */
if (argc < 2) {
verify_macaddr(&dev, NULL);
return 0;
}
/* Print help message */
if (argv[1][1] == 'h') {
printf("VoiceBlue EEPROM writer\n");
printf("Built: %s at %s\n", U_BOOT_DATE, U_BOOT_TIME);
printf("Usage:\n\t<mac_address> [<element_1>] [<...>]\n");
return 0;
}
/* Try to parse information elements */
len = sizeof(buf);
p = buf;
for (i = 2; i < argc; i++) {
ret = parse_element(argv[i], p, len);
switch (ret) {
case -1:
printf("Element %d: malformed\n", i - 1);
return 3;
case -2:
printf("Element %d: odd character count\n", i - 1);
return 3;
case -3:
printf("Out of EEPROM memory\n");
return 3;
default:
p += ret;
len -= ret;
}
}
/* First argument (MAC) is mandatory */
set_mac(&dev, argv[1]);
if (verify_macaddr(&dev, argv[1])) {
printf("*** MAC address does not match! ***\n");
return 4;
}
while (len--)
*p++ = 0;
write_data(&dev, (u16 *)buf, sizeof(buf) >> 1);
return 0;
}
/**
**===========================================================================
**
** Abstract: main program
**
**===========================================================================
*/
int main(void)
{
#if SYS_STARTUP == 0
SystemInit();
#endif
nvic_init(); // настройка векторов прерываний
led_init(); // инициализация светодиода, индицирующего работу процессора
init_calendar(); // инициализация календаря
_SPI_init(); // SPI для внешней FRAM
// чтение заводских установок
read_data(0x7B,0x00,128,(unsigned char*)&_Sys.FR.b1[0]);
read_data(0x7B,0x80,128,(unsigned char*)&_Sys.FR.b1[0x80]);
read_data(0x7C,0x00,128,(unsigned char*)&_Sys.FR.b1[0x100]);
read_data(0x7C,0x80,128,(unsigned char*)&_Sys.FR.b1[0x180]);
read_data(0x7D,0x00,128,(unsigned char*)&_Sys.FR.b1[0x200]);
read_data(0x7D,0x80,128,(unsigned char*)&_Sys.FR.b1[0x280]);
read_data(0x7E,0x00,128,(unsigned char*)&_Sys.FR.b1[0x300]);
read_data(0x7E,0x80,128,(unsigned char*)&_Sys.FR.b1[0x380]);
// чтение системных настроек контроллера
//read_data(0x7F,0x58,1,&rf_ch);
read_data(0x7F,0x00,6,(unsigned char*)&_Sys.Mem.b1[0]);
_Sys.Adr=_Sys.Mem.b1[0];
if((_Sys.Adr==0)||(_Sys.Adr==0xFF)) _Sys.Adr=0x01;
_Sys.Can1_Baudrate=_Sys.Mem.b1[1];
if(_Sys.Can1_Baudrate>5) _Sys.Can1_Baudrate=5;
_Sys.Can1_Type = _Sys.Mem.b1[2];
if(_Sys.Can1_Type>1) _Sys.Can1_Type=0;
_Sys.Can2_Baudrate=_Sys.Mem.b1[3];
if(_Sys.Can2_Baudrate>5) _Sys.Can2_Baudrate=5;
_Sys.Can2_Type = _Sys.Mem.b1[4];
if(_Sys.Can2_Type>1) _Sys.Can2_Type=0;
emu_mode = _Sys.Mem.b1[5];
if(emu_mode>2) emu_mode=0;
read_data(0x7F,0x4C,4,ip_addr);set_ip(ip_addr);
read_data(0x7F,0x50,6,mac_addr);set_mac(mac_addr);
read_data(0x7F,0x5A,4,ip_gate);set_gate(ip_gate);
read_data(0x7F,0x5E,1,&modbus_master_emu);
read_data(0x7F,0x5F,4,ip_mask);set_mask(ip_mask);
#if FRAM_YEAR
read_data(0x7F,0x56,1,(unsigned char*)×.year);
if(times.year>99) times.year=0;
#endif
read_data(0x7F,0x57,1,(unsigned char*)&pult_dis);
read_data(0x7F,0x59,1,(unsigned char*)&sd_dis);
/* read_data(0x7F,0x5A,32,ssid_name);
read_data(0x7F,0x7A,32,wifi_password);
read_data(0x7F,0x9A,1,&wifi_type);
read_data(0x7F,0x9B,4,wifi_ip);*/
// начальные значения номеров строк пульта
_Sys.S1=0x00;_Sys.S2=0x00;_Sys.S3=0x00;_Sys.S4=0x00;
// системные миллисекундные задачи
xTaskCreate( R1Task, ( signed portCHAR * ) "R1", configMINIMAL_STACK_SIZE*2, NULL, R1_TASK_PRIORITY, NULL );
xTaskCreate( R5Task, ( signed portCHAR * ) "R5", configMINIMAL_STACK_SIZE*2, NULL, R5_TASK_PRIORITY, NULL );
xTaskCreate( R10Task, ( signed portCHAR * ) "R10", configMINIMAL_STACK_SIZE*2, NULL, R10_TASK_PRIORITY, NULL );
xTaskCreate( R100Task, ( signed portCHAR * ) "R100", configMINIMAL_STACK_SIZE*2, NULL, R100_TASK_PRIORITY, NULL );
xTaskCreate( R1000Task, ( signed portCHAR * ) "R1000", configMINIMAL_STACK_SIZE*2, NULL, R1000_TASK_PRIORITY, NULL );
// служебная вспомогательная задача (светодиод,фильтр ацп,...)
xTaskCreate( prvFlashTask, (signed portCHAR *) "Flash", configMINIMAL_STACK_SIZE*2, NULL, mainFLASH_TASK_PRIORITY, NULL );
// стандартный пульт или коммуникационный канал
if(pult_dis!=0x31) xTaskCreate( LCDTask, ( signed portCHAR * ) "Lcd", configMINIMAL_STACK_SIZE*2, NULL, LCD_TASK_PRIORITY, NULL );
else xTaskCreate( PultCanTask, ( signed portCHAR * ) "Lcd", configMINIMAL_STACK_SIZE*5, NULL, Canal_TASK_PRIORITY, NULL );
// задача обработки входов/выходов включая модули расширения
xTaskCreate( InOutTask, ( signed portCHAR * ) "InOut", configMINIMAL_STACK_SIZE*2, NULL, InOut_TASK_PRIORITY, NULL );
// два основных коммуникационных канала RS485
if(_Sys.Can1_Type==0) xTaskCreate( BinCanTask, ( signed portCHAR * ) "Canal", configMINIMAL_STACK_SIZE*2, NULL, Canal_TASK_PRIORITY, NULL );
else xTaskCreate( AsciiCanTask, ( signed portCHAR * ) "Canal", configMINIMAL_STACK_SIZE*2, NULL, Canal_TASK_PRIORITY, NULL );
if(_Sys.Can2_Type==0) xTaskCreate( BinCan2Task, ( signed portCHAR * ) "Canal2", configMINIMAL_STACK_SIZE*2, NULL, Canal_TASK_PRIORITY, NULL );
else xTaskCreate( AsciiCan2Task, ( signed portCHAR * ) "Canal2", configMINIMAL_STACK_SIZE*2, NULL, Canal_TASK_PRIORITY, NULL );
// WIFI задачи
/* if(wifi_ip[0])
{
xTaskCreate( WIFITask, ( signed portCHAR * ) "Wifi", configMINIMAL_STACK_SIZE, NULL, WF_TASK_PRIORITY, NULL );
xTaskCreate( SCAN_WIFITask, ( signed portCHAR * ) "SCANWifi", configMINIMAL_STACK_SIZE, NULL, WF_TASK_PRIORITY+1, NULL );
}*/
// проводной ethernet
if(ip_addr[0]) xTaskCreate( EthTask, ( signed portCHAR * ) "Eth", configMINIMAL_STACK_SIZE*3, NULL, ETH_TASK_PRIORITY, NULL );
// задача работы с sd картой
if(sd_dis==0x31) xTaskCreate( ArchiveTask, ( signed portCHAR * ) "SD_Task", configMINIMAL_STACK_SIZE*2, NULL, SD_TASK_PRIORITY, NULL );
Relkon_init(); // блок инициализации - формируется верхним уровнем (раздел #init релкона)
init_timer(); // аппаратный таймер для определения загрузки процессора
vTaskStartScheduler(); // старт планировщика задач
while (1){}
}
void threecom3c505_device::do_command()
{
pcb_struct &command_pcp = (pcb_struct &) m_command_buffer;
// default to successful completion
m_response.command = command_pcp.command + CMD_RESPONSE_OFFSET;
m_response.length = 1;
m_response.data.failed = 0; // successful completion
switch (command_pcp.command)
{
case CMD_RESET: // 0x00
// FIXME: should never occur
break;
case CMD_CONFIGURE_ADAPTER_MEMORY: // 0x01
// TODO
break;
case CMD_CONFIGURE_82586: // 0x02
m_i82586_config = command_pcp.data.raw[0] + (command_pcp.data.raw[1] << 8);
break;
case CMD_RECEIVE_PACKET: // 0x08
// preset response PCB from the Receive Command PCB
m_rcv_response.command = CMD_RECEIVE_PACKET_COMPLETE; // 0x38
m_rcv_response.length = sizeof(struct Rcv_resp);
m_rcv_response.data.rcv_resp.buf_ofs = command_pcp.data.rcv_pkt.buf_ofs;
m_rcv_response.data.rcv_resp.buf_seg = command_pcp.data.rcv_pkt.buf_seg;
m_rcv_response.data.rcv_resp.buf_len = command_pcp.data.rcv_pkt.buf_len;
m_rcv_response.data.rcv_resp.pkt_len = 0;
m_rcv_response.data.rcv_resp.timeout = 0;
m_rcv_response.data.rcv_resp.status = 0;
m_rcv_response.data.rcv_resp.timetag = 0L; // TODO
m_rx_pending++;
set_command_pending(0);
return;
// break;
case CMD_TRANSMIT_PACKET_F9:
m_response.command = CMD_TRANSMIT_PACKET_COMPLETE;
// fall through
case CMD_TRANSMIT_PACKET: // 0x09
case CMD_TRANSMIT_PACKET_18: // 0x18
m_response.length = sizeof(struct Xmit_resp);
m_response.data.xmit_resp.buf_ofs = 0;
m_response.data.xmit_resp.buf_seg = 0;
m_response.data.xmit_resp.c_stat = 0; // successful completion
m_response.data.xmit_resp.status = 0;
break;
case CMD_EXECUTE_PROGRAM: // 0x0e
// m_response.length = 0;
// FIXME: hack?
m_status |= ASF_PCB_END;
break;
case CMD_NETWORK_STATISTICS: // 0x0a
m_response.length = sizeof(struct Netstat);
m_response.data.netstat.tot_recv = uint16_to_le(m_netstat.tot_recv);
m_response.data.netstat.tot_xmit = uint16_to_le(m_netstat.tot_xmit);
m_response.data.netstat.err_CRC = uint16_to_le(m_netstat.err_CRC);
m_response.data.netstat.err_align = uint16_to_le(m_netstat.err_align);
m_response.data.netstat.err_res = uint16_to_le(m_netstat.err_res);
m_response.data.netstat.err_ovrrun = uint16_to_le(m_netstat.err_ovrrun);
break;
case CMD_ADAPTER_INFO: // 0x11
m_response.length = sizeof(struct Info);
// FIXME: using demo data
m_response.data.info.minor_vers = 1;
m_response.data.info.major_vers = 2;
m_response.data.info.ROM_cksum = uint16_to_le(3);
m_response.data.info.RAM_sz = uint16_to_le(4);
m_response.data.info.free_ofs = uint16_to_le(5);
m_response.data.info.free_seg = uint16_to_le(6);
break;
case CMD_LOAD_MULTICAST_LIST:// 0x0b
if (command_pcp.length > sizeof(m_multicast_list)
|| (command_pcp.length % ETHERNET_ADDR_SIZE) != 0)
{
LOG(("CMD_LOAD_MULTICAST_LIST - unexpected data size %d", command_pcp.length));
}
else
{
memset(m_multicast_list, 0, sizeof(m_multicast_list));
memcpy(m_multicast_list, command_pcp.data.multicast, command_pcp.length- 2);
set_filter_list();
}
break;
case CMD_SET_STATION_ADDRESS: // 0x10
if (command_pcp.length != sizeof(m_station_address))
{
LOG(("CMD_SET_STATION_ADDRESS - unexpected data size %d", command_pcp.length));
memset(m_station_address, 0, sizeof(m_station_address));
}
else
{
memcpy(m_station_address, command_pcp.data.eth_addr, command_pcp.length);
}
set_filter_list();
set_mac((char *) m_station_address);
break;
case CMD_MC_17: // 0x17
m_microcode_running = 1;
break;
case CMD_DOWNLOAD_PROGRAM: // 0x0d
UINT16 mc_version = m_program_buffer.get_word(1);
switch (mc_version)
{
case APOLLO_MC_VERSION_SR10_2:
case APOLLO_MC_VERSION_SR10_4:
m_microcode_version = mc_version;
break;
default:
m_microcode_version = 0;
LOG(("CMD_DOWNLOAD_PROGRAM - unexpected microcode version %04x", mc_version));
break;
}
// return microcode version as program id
m_response.length = 2;
m_response.data.raw[0] = m_microcode_version & 0xff;
m_response.data.raw[1] = (m_microcode_version >> 8) & 0xff;
break;
}
m_response_index = 0;
m_response_length = m_response.length + 2;
m_status |= ACRF; /* set adapter command register full */
if (m_control & CMDE)
{
set_interrupt(ASSERT_LINE);
}
}
void threecom3c505_device::do_command()
{
// default to successful completion
m_response.command = m_command_buffer[0] + CMD_RESPONSE_OFFSET;
m_response.length = 1;
m_response.data.failed = 0; // successful completion
switch (m_command_buffer[0])
{
case CMD_RESET: // 0x00
// FIXME:
// device_reset();
break;
case CMD_CONFIGURE_ADAPTER_MEMORY: // 0x01
m_i82586_config = m_program_buffer.get_word(1);
break;
case CMD_RECEIVE_PACKET: // 0x08
if (m_rx_data_buffer.get_length() == 0 && !m_rx_fifo.get(&m_rx_data_buffer))
{
// receive data not yet available
m_rx_pending++;
set_command_pending(0);
}
else
{
do_receive_command();
}
return;
// break;
case CMD_MC_F9:
m_response.command = CMD_TRANSMIT_PACKET_COMPLETE;
// fall through
case CMD_TRANSMIT_PACKET: // 0x09
case CMD_TRANSMIT_PACKET_18: // 0x18
m_response.length = 8;
m_response.data.xmit_resp.buf_ofs = 0;
m_response.data.xmit_resp.buf_seg = 0;
m_response.data.xmit_resp.c_stat = 0; // successful completion
m_response.data.xmit_resp.status = 0;
break;
case CMD_EXECUTE_PROGRAM: // 0x0e
m_response.length = 0;
m_microcode_running = 1;
m_microcode_version = m_program_buffer.get_word(1);
break;
case CMD_NETWORK_STATISTICS: // 0x0a
m_response.length = sizeof(struct Netstat);
// response data must be LSB first!
m_response.data.netstat.tot_recv = lsb_first(m_netstat.tot_recv);
m_response.data.netstat.tot_xmit = lsb_first(m_netstat.tot_xmit);
m_response.data.netstat.err_CRC = lsb_first(m_netstat.err_CRC);
m_response.data.netstat.err_align = lsb_first(m_netstat.err_align);
m_response.data.netstat.err_res = lsb_first(m_netstat.err_res);
m_response.data.netstat.err_ovrrun = lsb_first(m_netstat.err_ovrrun);
break;
case CMD_ADAPTER_INFO: // 0x11
m_response.length = sizeof(struct Info);
// FIXME: replace test data; must be LSB first!
m_response.data.info.minor_vers = 1;
m_response.data.info.major_vers = 2;
m_response.data.info.ROM_cksum = lsb_first(3);
m_response.data.info.RAM_sz = lsb_first(4);
m_response.data.info.free_ofs = lsb_first(5);
m_response.data.info.free_seg = lsb_first(6);
break;
case CMD_LOAD_MULTICAST_LIST:// 0x0b
if (m_command_buffer[1] > sizeof(m_multicast_list) ||
(m_command_buffer[1] % ETHERNET_ADDR_SIZE) != 0)
{
LOG(("CMD_LOAD_MULTICAST_LIST - !!! unexpected data size %d !!!", m_command_buffer[1]));
}
else
{
memset(m_multicast_list, 0 , sizeof(m_multicast_list));
memcpy(m_multicast_list, m_command_buffer+2 , m_command_buffer[1]-2);
set_filter_list();
}
break;
case CMD_SET_STATION_ADDRESS: // 0x10
if (m_command_buffer[1] != sizeof(m_station_address))
{
LOG(("CMD_SET_STATION_ADDRESS - !!! unexpected data size %d !!!", m_command_buffer[1]));
memset(m_station_address, 0 , sizeof(m_station_address));
}
else
{
memcpy(m_station_address, m_command_buffer+2 , m_command_buffer[1]);
}
set_filter_list();
set_mac((char *)m_station_address);
break;
case CMD_CONFIGURE_82586: // 0x02
case CMD_DOWNLOAD_PROGRAM: // 0x0d
case CMD_MC_17: // 0x17
default:
break;
}
m_response_index = 0;
m_response_length = m_response.length + 2;
m_status |= ACRF; /* adapter command register full */
if (m_control & CMDE)
{
switch (m_command_buffer[0])
{
case CMD_NETWORK_STATISTICS: // 0x0a
case CMD_DOWNLOAD_PROGRAM: // 0xd
case CMD_EXECUTE_PROGRAM: // 0x0e
case CMD_ADAPTER_INFO: // 0x11
// interrupt later
m_timer->adjust( attotime::from_msec(5));
break;
default:
// interrupt at once
set_interrupt(ASSERT_LINE);
break;
}
}
}
