AthenaEthernet *
athenaEthernet_Create(PARCLog *log, const char *interface, uint16_t etherType)
{
AthenaEthernet *athenaEthernet = parcObject_CreateAndClearInstance(AthenaEthernet);
athenaEthernet->log = parcLog_Acquire(log);
athenaEthernet->etherType = etherType;
athenaEthernet->fd = _open_socket(interface);
if (athenaEthernet->fd == -1) {
parcLog_Error(athenaEthernet->log, "socket: %s", strerror(errno));
athenaEthernet_Release(&athenaEthernet);
return NULL;
}
if (ioctl(athenaEthernet->fd, BIOCGBLEN, &(athenaEthernet->etherBufferLength))) {
perror("error getting buffer length");
return NULL;
}
// Populate the configured physical MAC and MTU by searching ifaddrs
struct ifaddrs *ifaddr;
int res = getifaddrs(&ifaddr);
if (res == -1) {
perror("getifaddrs");
return 0;
}
struct ifaddrs *next;
for (next = ifaddr; next != NULL; next = next->ifa_next) {
if (strcmp(next->ifa_name, interface) == 0) {
if (next->ifa_addr->sa_family == AF_LINK) {
struct sockaddr_dl *addr_dl = (struct sockaddr_dl *) next->ifa_addr;
// addr_dl->sdl_data[12] contains the interface name followed by the MAC address, so
// need to offset in to the array past the interface name.
memcpy(&(athenaEthernet->mac), &addr_dl->sdl_data[addr_dl->sdl_nlen], addr_dl->sdl_alen);
struct if_data *ifdata = (struct if_data *) next->ifa_data;
athenaEthernet->mtu = ifdata->ifi_mtu;
// break out of loop and freeifaddrs
break;
}
}
}
freeifaddrs(ifaddr);
return athenaEthernet;
}
void syscall_handler()
{
static int free_vm_proc;
int syscall_num;
unsigned int mem_size;
struct t_process_context* current_process_context;
struct t_processor_reg processor_reg;
int* params;
char data;
unsigned int on_exit_action;
SAVE_PROCESSOR_REG
//call can come from kernel mode (sleep)
SWITCH_DS_TO_KERNEL_MODE
on_exit_action=0;
current_process_context=system.process_info->current_process->val;
t_console_desc *console_desc=current_process_context->console_desc;
syscall_num=processor_reg.eax;
params=processor_reg.ecx;
if (syscall_num==1)
{
params[0]=_fork(processor_reg);
}
else if (syscall_num==2)
{
params[1]=_malloc(params[0]);
}
else if (syscall_num==3)
{
_free(params[0]);
}
else if (syscall_num==150)
{
params[1]=_bigMalloc(params[0]);
}
else if (syscall_num==151)
{
_bigFree(params[0]);
}
else if (syscall_num==4)
{
_write_char(console_desc,params[0]);
}
else if (syscall_num==5)
{
data=_read_char(console_desc);
*((char*)params[0])=data;
if (data==NULL)
{
on_exit_action=1;
}
}
else if (syscall_num==6)
{
_echo_char(console_desc,params[0]);
}
else if (syscall_num==7)
{
_enable_cursor(console_desc);
}
else if (syscall_num==8)
{
_disable_cursor(console_desc);
}
else if (syscall_num==9)
{
_update_cursor(console_desc);
}
else if (syscall_num==10)
{
_delete_char(console_desc);
}
else if (syscall_num==11)
{
_pause();
on_exit_action=1;
}
else if (syscall_num==12)
{
_awake(params[0]);
}
else if (syscall_num==13)
{
_exit(params[0]);
on_exit_action=2;
}
else if (syscall_num==14)
{
params[2]=_exec(params[0],params[1]);
}
else if (syscall_num==15)
{
_sleep_time(params[0]);
on_exit_action=1;
}
else if (syscall_num==18)
{
params[2]=_open(system.root_fs,(char*) params[0],params[1]);
on_exit_action=1;
}
else if (syscall_num==19)
{
params[1]=_close(system.root_fs,params[0]);
on_exit_action=1;
}
else if (syscall_num==20)
{
params[3]=_read(system.root_fs,params[0],params[1],params[2]);
on_exit_action=1;
}
else if (syscall_num==21)
{
params[3]=_write(system.root_fs,(void*)params[0],params[1],params[2]);
on_exit_action=1;
}
else if (syscall_num==22)
{
params[1]=_rm(system.root_fs,(char*)params[0]);
on_exit_action=1;
}
else if (syscall_num==23)
{
params[1]=_mkdir(system.root_fs,params[0]);
on_exit_action=1;
}
//syscall 24 and 25 test only
else if (syscall_num==24)
{
t_io_request* io_request;
io_request=kmalloc(sizeof(t_io_request));
io_request->device_desc=system.device_desc;
io_request->sector_count=params[0];
io_request->lba=params[1];
io_request->io_buffer=params[2];
io_request->process_context=current_process_context;
_read_28_ata(io_request);
kfree(io_request);
}
else if (syscall_num==25)
{
t_io_request* io_request;
io_request=kmalloc(sizeof(t_io_request));
io_request->device_desc=system.device_desc;
io_request->sector_count=params[0];
io_request->lba=params[1];
io_request->io_buffer=params[2];
io_request->process_context=current_process_context;
_write_28_ata(io_request);
kfree(io_request);
}
else if (syscall_num==26)
{
params[1]=_chdir(system.root_fs,(char*) params[0]);
on_exit_action=1;
}
else if (syscall_num==27)
{
params[2]=_stat(system.root_fs,(char*) params[0],params[1]);
}
else if (syscall_num==28)
{
params[1]=_open_socket(system.network_desc->socket_desc,params[0]);
}
else if (syscall_num==29)
{
params[3]=_bind(system.network_desc->socket_desc,params[0],params[1],params[2]);
}
else if (syscall_num==30)
{
params[5]=_recvfrom(system.network_desc->socket_desc,params[0],params[1],params[2],params[3],params[4]);
}
else if (syscall_num==31)
{
params[5]=_sendto(system.network_desc->socket_desc,params[0],params[1],params[2],params[3],params[4]);
}
else if (syscall_num==32)
{
params[1]=_close_socket(system.network_desc->socket_desc,params[0]);
}
else if (syscall_num==101)
{
on_exit_action=1;
}
else if (syscall_num==102)
{
_flush_ata_pending_request();
}
//DEBUG WRAPPER
else if (syscall_num==103)
{
check_free_mem();
}
else if (syscall_num==104)
{
debug_network(params[0],params[1]);
}
else
{
panic();
}
// EXIT_INT_HANDLER(on_exit_action,processor_reg)
static struct t_process_context _current_process_context;
static struct t_process_context _old_process_context;
static struct t_process_context _new_process_context;
static struct t_processor_reg _processor_reg;
static unsigned int _action;
// static short _ds;
CLI
// _ds=ds;
_action=on_exit_action;
_current_process_context=*(struct t_process_context*)system.process_info->current_process->val;
_old_process_context=_current_process_context;
_processor_reg=processor_reg;
if (_action>0)
{
schedule(&_current_process_context,&_processor_reg);
_new_process_context=*(struct t_process_context*)(system.process_info->current_process->val);
_processor_reg=_new_process_context.processor_reg;
SWITCH_PAGE_DIR(FROM_VIRT_TO_PHY(((unsigned int) _new_process_context.page_dir)))
DO_STACK_FRAME(_processor_reg.esp-8);
// unsigned int* xxx;
// unsigned int* yyy;
// unsigned int* zzz;
// xxx=FROM_PHY_TO_VIRT(((unsigned int*)_new_process_context.page_dir)[0]) & 0xFFFFF000;
// zzz=FROM_PHY_TO_VIRT(xxx[256]);
if (_action==2)
{
DO_STACK_FRAME(_processor_reg.esp-8);
// free_vm_process(_old_process_context.page_dir,INIT_VM_USERSPACE);
free_vm_process(&_old_process_context);
// if (_old_process_context.phy_add_space!=NULL)
// {
// buddy_free_page(&system.buddy_desc,FROM_PHY_TO_VIRT(_old_process_context.phy_add_space));
// buddy_free_page(system.buddy_desc,FROM_PHY_TO_VIRT(_old_process_context.phy_user_stack));
// }
buddy_free_page(system.buddy_desc,FROM_PHY_TO_VIRT(_old_process_context.phy_kernel_stack));
}
RESTORE_PROCESSOR_REG
EXIT_SYSCALL_HANDLER
}
hash_t ZLookupClient::lookup_url(const char *url)
{
mutex->lock();
// ZLC_TERSE(ze, "liang: ZLookupClient::lookup_url %s\n",, url);
_open_socket();
nonce++;
int url0len = lite_strlen(url)+1;
int lookup_len = sizeof(ZFTPHashLookupRequestPacket)+url0len;
ZFTPHashLookupRequestPacket *lookup =
(ZFTPHashLookupRequestPacket *) alloca(lookup_len);
lookup->nonce = z_htong(nonce, sizeof(lookup->nonce));
lookup->url_hint_len = z_htons(url0len);
char *url_hint = (char*) &lookup[1];
lite_memcpy(url_hint, url, url0len);
ZeroCopyBuf *zcb;
ZFTPHashLookupReplyPacket *reply = NULL;
bool retransmissions = false;
bool transmit = true;
while (true)
{
reply = NULL;
if (transmit)
{
bool rc;
rc = sock->sendto(origin_lookup, lookup, lookup_len);
lite_assert(rc);
transmit = false;
}
zcb = sock->recvfrom(NULL);
if (zcb==NULL)
{
// close the sock later, to keep duplicate replies from piling up.
retransmissions = true;
transmit = true;
continue;
}
lite_assert(zcb->len()==sizeof(ZFTPHashLookupReplyPacket));
reply = (ZFTPHashLookupReplyPacket *) zcb->data();
if (Z_NTOHG(reply->nonce)!=nonce)
{
ZLC_COMPLAIN(ze, "wrong nonce (old?)\n");
// don't retransmit; just wait again.
delete zcb;
continue;
}
break;
}
lite_assert(zcb!=NULL); // we retry forever above.
lite_assert(Z_NTOHG(reply->hash_len)==sizeof(hash_t));
//lite_assert(!is_zero_hash(&reply.hash));
if (retransmissions)
{
delete sock;
sock = NULL;
}
mutex->unlock();
hash_t result = reply->hash;
delete zcb;
return result;
}
