// Handle sniff message
short lister_handle_sniff(Lister *lister,SniffData *data)
{
DirEntry *entry;
long off;
short show=0;
// Find entry
if ((entry=find_entry(&data->buffer->entry_list,data->name,&off,data->buffer->more_flags&DWF_CASE)))
{
char *version=0,*type=0;
char buf[40];
// Got a filetype?
if (data->type || *data->type_name)
{
// Get name pointer
if ((type=(data->type)?data->type->type.name:data->type_name) && *type)
{
// Set filetype description
direntry_add_string(data->buffer,entry,DE_Filetype,type);
// Directory sorted by filetype?
if (data->buffer->buf_ListFormat.sort.sort==DISPLAY_FILETYPE)
{
// Remove entry
remove_file_entry(data->buffer,entry);
// Add it again
add_file_entry(data->buffer,entry,0);
show|=SNIFFF_SHOW;
}
}
}
// Got a version?
if (data->flags&SNIFFF_VERSION)
{
// Set version
direntry_add_version(data->buffer,entry,data->ver,data->rev,data->days);
// Build version string
build_version_string(buf,data->ver,data->rev,data->days,-1);
version=buf;
// Directory sorted by version?
if (data->buffer->buf_ListFormat.sort.sort==DISPLAY_VERSION)
{
// Remove entry
remove_file_entry(data->buffer,entry);
// Add it again
add_file_entry(data->buffer,entry,0);
show|=SNIFFF_SHOW;
}
}
// Is buffer currently visible?
if (lister->cur_buffer==data->buffer &&
!(lister->flags&LISTERF_VIEW_ICONS))
{
short len;
// Type field changed, and don't have a custom width for filetype field?
if (type && *type && !(data->buffer->buf_CustomWidthFlags&(1<<DISPLAY_FILETYPE)))
{
short old;
// Get new field size
old=data->buffer->buf_FieldWidth[DISPLAY_FILETYPE];
lister_check_max_length(lister,type,&len,DISPLAY_FILETYPE);
old-=data->buffer->buf_FieldWidth[DISPLAY_FILETYPE];
// Field needs to be bigger?
if (old<0)
{
// Add to width
data->buffer->buf_HorizLength-=old;
if (data->buffer->type_length<len)
data->buffer->type_length=len;
show|=SNIFFF_SLIDERS;
}
}
// Same for version field
if (version && !(data->buffer->buf_CustomWidthFlags&(1<<DISPLAY_VERSION)))
{
short old;
// Get new field size
old=data->buffer->buf_FieldWidth[DISPLAY_VERSION];
lister_check_max_length(lister,version,&len,DISPLAY_VERSION);
old-=data->buffer->buf_FieldWidth[DISPLAY_VERSION];
// Field needs to be bigger?
if (old<0)
{
// Add to width
data->buffer->buf_HorizLength-=old;
if (data->buffer->version_length<len)
data->buffer->version_length=len;
show|=SNIFFF_SLIDERS;
}
}
// Update slider?
if (show&SNIFFF_SLIDERS)
show|=SNIFFF_SHOW;
// Don't need to redraw?
else
if (!(show&SNIFFF_SHOW))
{
// Is entry visible?
if (off>=lister->cur_buffer->buf_VertOffset &&
off<lister->cur_buffer->buf_VertOffset+lister->text_height)
{
// Show entry
display_entry(entry,lister,off-lister->cur_buffer->buf_VertOffset);
}
}
}
else show=0;
}
return show;
}
BOOL datamap_read_control(datamap *map, HWND dialog, windows_options &opts, int dlgitem)
{
datamap_entry *entry = find_entry(map, dlgitem);
return control_operation(map, dialog, &opts, entry, DCT_READ_CONTROL);
}
void datamap_update_control(datamap *map, HWND dialog, windows_options &opts, int dlgitem)
{
datamap_entry *entry = find_entry(map, dlgitem);
control_operation(map, dialog, &opts, entry, DCT_UPDATE_STATUS);
}
/**
* Set command
*/
void command_set(const char* line) {
char cmd[MAX_BUFFER];
char key[MAX_BUFFER];
char func[MAX_BUFFER];
char arg1[MAX_BUFFER];
char arg2[MAX_BUFFER];
int argc = sscanf(line, "%s %s = %s %s %s", cmd, key, func, arg1, arg2);
if (argc < 3) {
puts("invalid arguments");
return;
}
uint32_t* matrix = NULL;
switch (argc) {
case 3:
if (strcasecmp(func, "identity") == 0) {
matrix = identity_matrix();
} else {
goto invalid;
}
break;
case 4:
if (strcasecmp(func, "random") == 0) {
uint32_t seed = atoll(arg1);
matrix = random_matrix(seed);
} else if (strcasecmp(func, "uniform") == 0) {
uint32_t value = atoll(arg1);
matrix = uniform_matrix(value);
} else if (strcasecmp(func, "cloned") == 0) {
MATRIX_GUARD(arg1);
matrix = cloned(m);
} else if (strcasecmp(func, "reversed") == 0) {
MATRIX_GUARD(arg1);
matrix = reversed(m);
} else if (strcasecmp(func, "transposed") == 0) {
MATRIX_GUARD(arg1);
matrix = transposed(m);
} else {
goto invalid;
}
break;
case 5:
if (strcasecmp(func, "sequence") == 0) {
uint32_t start = atoll(arg1);
uint32_t step = atoll(arg2);
matrix = sequence_matrix(start, step);
} else if (strcasecmp(func, "scalar#add") == 0) {
MATRIX_GUARD(arg1);
uint32_t value = atoll(arg2);
matrix = scalar_add(m, value);
} else if (strcasecmp(func, "scalar#mul") == 0) {
MATRIX_GUARD(arg1);
uint32_t value = atoll(arg2);
matrix = scalar_mul(m, value);
} else if (strcasecmp(func, "matrix#add") == 0) {
MATRIX_GUARD_PAIR(arg1, arg2);
matrix = matrix_add(m1, m2);
} else if (strcasecmp(func, "matrix#mul") == 0) {
MATRIX_GUARD_PAIR(arg1, arg2);
matrix = matrix_mul(m1, m2);
} else if (strcasecmp(func, "matrix#pow") == 0) {
MATRIX_GUARD(arg1);
uint32_t exponent = atoll(arg2);
matrix = matrix_pow(m, exponent);
} else {
goto invalid;
}
break;
}
entry* e = find_entry(key);
if (e == NULL) {
e = add_entry(key);
} else {
free(e->matrix);
}
e->matrix = matrix;
puts("ok");
return;
invalid:
puts("invalid arguments");
}
void datamap_set_option_name_callback(datamap *map, int dlgitem, get_option_name_callback get_option_name)
{
datamap_entry *entry;
entry = find_entry(map, dlgitem);
entry->get_option_name = get_option_name;
}
/*
* open_namei()
*
* namei for open - this is in fact almost the whole open-routine.
*/
int open_namei(const char * pathname, int flag, int mode,
struct m_inode ** res_inode)
{
const char * basename;
int inr,dev,namelen;
struct m_inode * dir, *inode;
struct buffer_head * bh;
struct dir_entry * de;
if ((flag & O_TRUNC) && !(flag & O_ACCMODE))
flag |= O_WRONLY;
mode &= 0777 & ~current->umask;
mode |= I_REGULAR;
if (!(dir = dir_namei(pathname,&namelen,&basename)))
return -ENOENT;
if (!namelen) { /* special case: '/usr/' etc */
if (!(flag & (O_ACCMODE|O_CREAT|O_TRUNC))) {
*res_inode=dir;
return 0;
}
iput(dir);
return -EISDIR;
}
bh = find_entry(&dir,basename,namelen,&de);
if (!bh) {
if (!(flag & O_CREAT)) {
iput(dir);
return -ENOENT;
}
if (!permission(dir,MAY_WRITE)) {
iput(dir);
return -EACCES;
}
inode->i_mode = mode;
bh = add_entry(dir,basename,namelen,&de);
if (!bh) {
inode->i_nlinks--;
iput(inode);
iput(dir);
return -ENOSPC;
}
bh->b_dirt = 1;
brelse(bh);
iput(dir);
*res_inode = inode;
return 0;
}
inr = de->inode;
dev = dir->i_dev;
brelse(bh);
iput(dir);
if (flag & O_EXCL)
return -EEXIST;
if (!(inode=iget(dev,inr)))
return -EACCES;
if ((S_ISDIR(inode->i_mode) && (flag & O_ACCMODE)) ||
!permission(inode,ACC_MODE(flag))) {
iput(inode);
return -EPERM;
}
inode->i_atime = CURRENT_TIME;
if (flag & O_TRUNC)
truncate(inode);
*res_inode = inode;
return 0;
}
static void test_system_tables( void )
{
UINT r;
const char *query;
MSIHANDLE hproduct, hdb, hview, hrec;
if (!pMsiApplyPatchA)
{
win_skip("MsiApplyPatchA is not available\n");
return;
}
if (is_process_limited())
{
skip("process is limited\n");
return;
}
CreateDirectoryA( "msitest", NULL );
create_file( "msitest\\patch.txt", 1000 );
create_database( msifile, tables, sizeof(tables) / sizeof(struct msi_table) );
create_patch( mspfile );
MsiSetInternalUI( INSTALLUILEVEL_NONE, NULL );
r = MsiInstallProductA( msifile, NULL );
if (r != ERROR_SUCCESS)
{
skip("Product installation failed with error code %d\n", r);
goto cleanup;
}
r = MsiOpenProductA( "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}", &hproduct );
ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
hdb = MsiGetActiveDatabase( hproduct );
ok( hdb, "failed to get database handle\n" );
r = find_entry( hdb, "_Streams", "\5SummaryInformation" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
query = "SELECT * FROM `_Storages`";
r = MsiDatabaseOpenView( hdb, query, &hview );
ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
r = MsiViewExecute( hview, 0 );
ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
r = MsiViewFetch( hview, &hrec );
ok( r == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %u\n", r );
r = find_entry( hdb, "_Tables", "Directory" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "File" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "Component" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "Feature" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "FeatureComponents" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "Property" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "InstallExecuteSequence" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "Media" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "_Property" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
MsiCloseHandle( hrec );
MsiViewClose( hview );
MsiCloseHandle( hview );
MsiCloseHandle( hdb );
MsiCloseHandle( hproduct );
r = MsiApplyPatchA( mspfile, NULL, INSTALLTYPE_DEFAULT, NULL );
ok( r == ERROR_SUCCESS || broken( r == ERROR_PATCH_PACKAGE_INVALID ), /* version 2.0 */
"expected ERROR_SUCCESS, got %u\n", r );
if (r == ERROR_PATCH_PACKAGE_INVALID)
{
win_skip("Windows Installer < 3.0 detected\n");
goto uninstall;
}
r = MsiOpenProductA( "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}", &hproduct );
ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
hdb = MsiGetActiveDatabase( hproduct );
ok( hdb, "failed to get database handle\n" );
r = find_entry( hdb, "_Streams", "\5SummaryInformation" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
query = "SELECT * FROM `_Storages`";
r = MsiDatabaseOpenView( hdb, query, &hview );
ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
r = MsiViewExecute( hview, 0 );
ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
r = MsiViewFetch( hview, &hrec );
ok( r == ERROR_NO_MORE_ITEMS, "expected ERROR_NO_MORE_ITEMS, got %u\n", r );
r = find_entry( hdb, "_Tables", "Directory" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "File" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "Component" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "Feature" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "FeatureComponents" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "Property" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "InstallExecuteSequence" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "Media" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "_Property" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "MsiPatchHeaders" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "Patch" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
r = find_entry( hdb, "_Tables", "PatchPackage" );
ok( r == ERROR_SUCCESS, "failed to find entry %u\n", r );
MsiCloseHandle( hrec );
MsiViewClose( hview );
MsiCloseHandle( hview );
MsiCloseHandle( hdb );
MsiCloseHandle( hproduct );
uninstall:
r = MsiInstallProductA( msifile, "REMOVE=ALL" );
ok( r == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", r );
cleanup:
DeleteFileA( msifile );
DeleteFileA( mspfile );
DeleteFileA( "msitest\\patch.txt" );
RemoveDirectoryA( "msitest" );
}
/**
* Update (or insert) a IP/MAC address pair in the ARP cache.
*
* If a pending entry is resolved, any queued packets will be sent
* at this point.
*
* @param netif netif related to this entry (used for NETIF_ADDRHINT)
* @param ipaddr IP address of the inserted ARP entry.
* @param ethaddr Ethernet address of the inserted ARP entry.
* @param flags @see definition of ETHARP_FLAG_*
*
* @return
* - ERR_OK Succesfully updated ARP cache.
* - ERR_MEM If we could not add a new ARP entry when ETHARP_FLAG_TRY_HARD was set.
* - ERR_ARG Non-unicast address given, those will not appear in ARP cache.
*
* @see pbuf_free()
*/
static err_t
update_arp_entry(struct netif *netif, ip_addr_t *ipaddr, struct eth_addr *ethaddr, u8_t flags)
{
s8_t i;
LWIP_ASSERT("netif->hwaddr_len == ETHARP_HWADDR_LEN", netif->hwaddr_len == ETHARP_HWADDR_LEN);
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F" - %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F"\n",
ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr),
ethaddr->addr[0], ethaddr->addr[1], ethaddr->addr[2],
ethaddr->addr[3], ethaddr->addr[4], ethaddr->addr[5]));
/* non-unicast address? */
if (ip_addr_isany(ipaddr) ||
ip_addr_isbroadcast(ipaddr, netif) ||
ip_addr_ismulticast(ipaddr)) {
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: will not add non-unicast IP address to ARP cache\n"));
return ERR_ARG;
}
/* find or create ARP entry */
i = find_entry(ipaddr, flags);
/* bail out if no entry could be found */
if (i < 0) {
return (err_t)i;
}
#if ETHARP_SUPPORT_STATIC_ENTRIES
if (flags & ETHARP_FLAG_STATIC_ENTRY) {
/* record static type */
arp_table[i].static_entry = 1;
}
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
/* mark it stable */
arp_table[i].state = ETHARP_STATE_STABLE;
#if LWIP_SNMP
/* record network interface */
arp_table[i].netif = netif;
#endif /* LWIP_SNMP */
/* insert in SNMP ARP index tree */
snmp_insert_arpidx_tree(netif, &arp_table[i].ipaddr);
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: updating stable entry %"S16_F"\n", (s16_t)i));
/* update address */
ETHADDR32_COPY(&arp_table[i].ethaddr, ethaddr);
/* reset time stamp */
arp_table[i].ctime = 0;
/* this is where we will send out queued packets! */
#if ARP_QUEUEING
while (arp_table[i].q != NULL) {
struct pbuf *p;
/* remember remainder of queue */
struct etharp_q_entry *q = arp_table[i].q;
/* pop first item off the queue */
arp_table[i].q = q->next;
/* get the packet pointer */
p = q->p;
/* now queue entry can be freed */
memp_free(MEMP_ARP_QUEUE, q);
#else /* ARP_QUEUEING */
if (arp_table[i].q != NULL) {
struct pbuf *p = arp_table[i].q;
arp_table[i].q = NULL;
#endif /* ARP_QUEUEING */
/* send the queued IP packet */
etharp_send_ip(netif, p, (struct eth_addr*)(netif->hwaddr), ethaddr);
/* free the queued IP packet */
pbuf_free(p);
}
return ERR_OK;
}
#if ETHARP_SUPPORT_STATIC_ENTRIES
/** Add a new static entry to the ARP table. If an entry exists for the
* specified IP address, this entry is overwritten.
* If packets are queued for the specified IP address, they are sent out.
*
* @param ipaddr IP address for the new static entry
* @param ethaddr ethernet address for the new static entry
* @return @see return values of etharp_add_static_entry
*/
err_t
etharp_add_static_entry(ip_addr_t *ipaddr, struct eth_addr *ethaddr)
{
struct netif *netif;
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_add_static_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F" - %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F"\n",
ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr),
ethaddr->addr[0], ethaddr->addr[1], ethaddr->addr[2],
ethaddr->addr[3], ethaddr->addr[4], ethaddr->addr[5]));
netif = ip_route(ipaddr);
if (netif == NULL) {
return ERR_RTE;
}
return update_arp_entry(netif, ipaddr, ethaddr, ETHARP_FLAG_TRY_HARD | ETHARP_FLAG_STATIC_ENTRY);
}
/** Remove a static entry from the ARP table previously added with a call to
* etharp_add_static_entry.
*
* @param ipaddr IP address of the static entry to remove
* @return ERR_OK: entry removed
* ERR_MEM: entry wasn't found
* ERR_ARG: entry wasn't a static entry but a dynamic one
*/
err_t
etharp_remove_static_entry(ip_addr_t *ipaddr)
{
s8_t i;
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_remove_static_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr)));
/* find or create ARP entry */
i = find_entry(ipaddr, ETHARP_FLAG_FIND_ONLY);
/* bail out if no entry could be found */
if (i < 0) {
return (err_t)i;
}
if ((arp_table[i].state != ETHARP_STATE_STABLE) ||
(arp_table[i].static_entry == 0)) {
/* entry wasn't a static entry, cannot remove it */
return ERR_ARG;
}
/* entry found, free it */
free_entry(i);
return ERR_OK;
}
/**
* Update (or insert) a IP/MAC address pair in the ARP cache.
*
* If a pending entry is resolved, any queued packets will be sent
* at this point.
*
* @param ipaddr IP address of the inserted ARP entry.
* @param ethaddr Ethernet address of the inserted ARP entry.
* @param flags Defines behaviour:
* - ETHARP_CREATE Allows ARP to insert this as a new item. If not specified,
* only existing ARP entries will be updated.
*
* @return
* - ERR_OK Succesfully updated ARP cache.
* - ERR_MEM If we could not add a new ARP entry when ETHARP_CREATE was set.
* - ERR_ARG Non-unicast address given, those will not appear in ARP cache.
*
* @see pbuf_free()
*/
err_t
update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *ethaddr, u8_t flags)
{
s8_t i, k;
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | 3, ("update_arp_entry()\n"));
LWIP_ASSERT("netif->hwaddr_len != 0", netif->hwaddr_len != 0);
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: %u.%u.%u.%u - %02x:%02x:%02x:%02x:%02x:%02x\n",
ip4_addr1(ipaddr), ip4_addr2(ipaddr), ip4_addr3(ipaddr), ip4_addr4(ipaddr),
ethaddr->addr[0], ethaddr->addr[1], ethaddr->addr[2],
ethaddr->addr[3], ethaddr->addr[4], ethaddr->addr[5]));
/* non-unicast address? */
if (ip_addr_isany(ipaddr) ||
ip_addr_isbroadcast(ipaddr, netif) ||
ip_addr_ismulticast(ipaddr)
) {
#ifdef LINKLOCAL_IP //Ron Add for Rendzvous 12/10/04
if( mRENVEnable && ip_addr_isany(ipaddr) )
{
if (LinkLocal_get_current_state()== NO_USE )
return ERR_ARG;
}
else
#endif
{
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: will not add non-unicast IP address to ARP cache\n"));
return ERR_ARG;
}
}
/* find or create ARP entry */
i = find_entry(ipaddr, flags);
/* bail out if no entry could be found */
if (i < 0) return (err_t)i;
/* mark it stable */
arp_table[i].state = ETHARP_STATE_STABLE;
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: updating stable entry %u\n", i));
/* update address */
for (k = 0; k < netif->hwaddr_len; ++k) {
arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];
}
/* reset time stamp */
arp_table[i].ctime = 0;
/* this is where we will send out queued packets! */
#if ARP_QUEUEING
while (arp_table[i].p != NULL) {
/* get the first packet on the queue (if any) */
struct pbuf *p = arp_table[i].p;
/* Ethernet header */
struct eth_hdr *ethhdr = p->payload;;
/* remember (and reference) remainder of queue */
/* note: this will also terminate the p pbuf chain */
arp_table[i].p = pbuf_dequeue(p);
/* fill-in Ethernet header */
for (k = 0; k < netif->hwaddr_len; ++k) {
ethhdr->dest.addr[k] = ethaddr->addr[k];
ethhdr->src.addr[k] = netif->hwaddr[k];
}
ethhdr->type = htons(ETHTYPE_IP);
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: sending queued IP packet %p.\n", (void *)p));
/* send the queued IP packet */
netif->linkoutput(netif, p);
/* free the queued IP packet */
pbuf_free(p);
}
#endif
return ERR_OK;
}
/** Same as aref(state, key). */
Object* LookupTable::fetch(STATE, Object* key) {
LookupTableBucket* entry = find_entry(state, key);
if(entry == cNil) return cNil;
return entry->value();
}
Object* LookupTable::has_key(STATE, Object* key) {
LookupTableBucket* entry = find_entry(state, key);
if(entry == cNil) return cFalse;
return cTrue;
}
int syscall_stat(const char *file_name, struct stat *buf)
{
int drive;
int curdir_handle;
char name_comp[13], conv_name[11], dir_path[501];
struct dir_entry dent;
int err, count;
struct date_time dt;
int clno;
if (strlen(file_name) > 500) return ELONGPATH;
parse_path(file_name, &drive, dir_path, name_comp);
if (dir_path[0] != 0)
{
curdir_handle = open_path(drive, dir_path);
if (curdir_handle < 0)
{
return curdir_handle; // Error
}
}
else
{
curdir_handle = get_curdir_handle(drive);
increment_ref_count(curdir_handle);
}
// Last file name component.
if (convert_name(name_comp, conv_name) < 0)
{
err = EINVALIDNAME; // Error
}
else if (find_entry(curdir_handle, conv_name, &dent) == 1)
{
// Fill up the stat buf
buf->st_dev = drive;
buf->st_ino = 0;
buf->st_mode = dent.attrib;
buf->st_nlink = 1;
buf->st_uid = buf->st_gid = 0;
buf->st_rdev = 0;
buf->st_size = dent.fsize;
buf->st_blksize = 512;
// Find time in seconds
dt.seconds = (dent.time & 0x1f) * 2;
dt.minutes = ((dent.time & 0x7e0) >> 5);
dt.hours = (((unsigned short int)(dent.time & 0xf800)) >> 11);
dt.date = dent.date & 0x1f;
dt.month = ((dent.date & 0x1e0) >> 5);
dt.year = (((unsigned short int)(dent.date & 0xfe00)) >> 9);
buf->st_atime = buf->st_mtime = buf->st_ctime = date_to_secs(dt);
// Find number of blocks
count = 0;
clno = dent.start_cluster;
while (clno < 0xff8)
{
count++;
clno = next_cluster_12(clno);
}
buf->st_blocks = count;
err = 0;
}
int syscall_rename(const char *a_oldpath, const char *a_newpath)
{
int ohandle, nhandle;
int drive1, drive2;
char dir_path1[512], dir_path2[512];
char name_comp1[13], name_comp2[13], conv_name1[11], conv_name2[11];
char oldpath[512], newpath[512];
struct dir_entry dent1, dent2;
int exist1, exist2;
struct DIR_FILE *dirf;
int len1, len2;
int i,t;
len1 = strlen(a_oldpath);
len2 = strlen(a_newpath);
if (len1 > 512 || len2 > 512) return ELONGPATH;
strcpy(oldpath,a_oldpath);
strcpy(newpath,a_newpath);
if (oldpath[len1-1] == '/' || oldpath[len1-1] == '\\') oldpath[len1-1] = '\0';
if (newpath[len2-1] == '/' || newpath[len2-1] == '\\') newpath[len2-1] = '\0';
parse_path(oldpath, &drive1, dir_path1, name_comp1);
parse_path(newpath, &drive2, dir_path2, name_comp2);
if (drive1 != drive2) return EDEVICE_DIFFERENT;
nhandle = open_path(drive2, dir_path2);
if (nhandle < 0) return nhandle;
if (name_comp2[0] !='\0')
{
if (convert_name(name_comp2, conv_name2) < 0)
{
close_dir(nhandle);
return EINVALIDNAME; // Error
}
exist2 = find_entry(nhandle, conv_name2, &dent2);
}
ohandle = open_path(drive1, dir_path1);
if (ohandle < 0)
{
close_dir(nhandle);
return ohandle;
}
if (name_comp1[0] != '\0')
{
if (convert_name(name_comp1, conv_name1) < 0)
{
close_dir(nhandle);
close_dir(ohandle);
return EINVALIDNAME; // Error
}
exist1 = find_entry(ohandle, conv_name1, &dent1);
}
// Check whether new path exists and is removable
if ((exist2 == 1) && ((dent2.attrib & FTYPE_READONLY) || ((dent2.attrib & FTYPE_DIR) && (empty_dir(nhandle, &dent2) != 1))))
{
close_dir(nhandle);
close_dir(ohandle);
return ETARGET_EXISTS;
}
// Check if source exists and is movable
if (exist1 != 1)
{
close_dir(nhandle);
close_dir(ohandle);
return EPATH_NOT_EXISTS;
}
if ((dent1.attrib & FTYPE_READONLY) != 0)
{
close_dir(nhandle);
close_dir(ohandle);
return EREADONLY;
}
// Check whether oldpath is not a subpath of newpath
if ((dent1.attrib & FTYPE_DIR) && (ohandle != nhandle))
{
t = nhandle;
dirf = &dir_file_list[t];
while (dirf->parent_index >= 0 && dirf->parent_index != ohandle)
{
t = dirf->parent_index;
dirf = &dir_file_list[t];
}
if (dirf->parent_index == ohandle)
{
close_dir(nhandle);
close_dir(ohandle);
return EOLDPATH_PARENT_OF_NEWPATH;
}
}
// Check if newpath already exists whether it is compatible or not
if ((exist2 == 1) && (((dent1.attrib & FTYPE_DIR) != 0 && (dent2.attrib & FTYPE_DIR) == 0) || ((dent1.attrib & FTYPE_DIR) == 0 && (dent2.attrib & FTYPE_DIR) != 0)))
{
close_dir(nhandle);
close_dir(ohandle);
return ESRC_DEST_NOT_SAME_TYPE;
}
// Remove destination entry if exists
if (exist2 == 1)
{
if (dent2.attrib & FTYPE_DIR)
syscall_rmdir(newpath);
else syscall_unlink(newpath);
}
// Add the source dir entry after changing the name
// to destination directory
bcopy( (char *)&dent1, (char *)&dent2, sizeof(struct dir_entry));
for (i=0; i<11; i++) // Both name and extension
dent2.name[i] = conv_name2[i];
t = add_dir_entry(nhandle, &dent2);
if (t == 1)
{
delete_dir_entry(ohandle, dent1.name);
}
// Close the handles of parent directories
close_dir(ohandle);
close_dir(nhandle);
if (t == 1) return 0;
else return t;
}
Object* MethodTable::has_name(STATE, Symbol* name) {
MethodTableBucket* entry = find_entry(state, name);
if(!entry) return cFalse;
return cTrue;
}
int
do_ds_read (struct ds_read_arg *arg, struct DSError *error, struct ds_read_result *result, DN binddn, DN target, struct di_block **di_p, int dsp, int quipu_ctx, int authtype)
{
Entry entryptr;
int retval;
#ifdef NOTUSED
int authenticated;
#endif
DN realtarget;
char authp;
DLOG (log_dsap,LLOG_TRACE,("ds_read"));
if (!dsp)
target = arg->rda_object;
if (!dsp && dsa_read_control(arg,result))
return (DS_OK);
if (target == NULLDN) {
/* can't read from the root */
error->dse_type = DSE_NAMEERROR;
error->ERR_NAME.DSE_na_problem = DSE_NA_NOSUCHOBJECT;
error->ERR_NAME.DSE_na_matched = NULLDN;
return (DS_ERROR_REMOTE);
}
switch(find_entry(target,&(arg->rda_common),binddn,NULLDNSEQ,FALSE,&(entryptr), error, di_p, OP_READ)) {
case DS_OK:
/* Filled out entryptr - carry on */
break;
case DS_CONTINUE:
/* Filled out di_p - what do we do with it ?? */
return(DS_CONTINUE);
case DS_X500_ERROR:
/* Filled out error - what do we do with it ?? */
return(DS_X500_ERROR);
default:
/* SCREAM */
LLOG(log_dsap, LLOG_EXCEPTIONS, ("do_ds_read() - find_entry failed"));
return(DS_ERROR_LOCAL);
}
realtarget = get_copy_dn (entryptr);
/* User can be authenticated by using strong authentication for this
* operation, or by using the credntials from the bind.
*/
if (!manager(binddn))
authp = entryptr->e_authp ? entryptr->e_authp->ap_readandcompare
: AP_SIMPLE;
else
authp = AP_SIMPLE;
#ifdef NOTUSED
authenticated = 0;
/* Credentials provided in the ds_bind */
if ((bind_policy & POLICY_ACCESS_READ) && (!dsp) && (binddn != NULLDN))
authenticated = 1;
#endif
/* Strong authentication */
/* If it's there, check it, even if you won't believe it anyway */
if ((retval = check_security_parms((caddr_t) arg,
_ZReadArgumentDataDAS,
&_ZDAS_mod,
arg->rda_common.ca_security,
arg->rda_common.ca_sig, &binddn)) != 0) {
error->dse_type = DSE_SECURITYERROR;
error->ERR_SECURITY.DSE_sc_problem = retval;
dn_free (realtarget);
return (DS_ERROR_REMOTE);
}
#ifdef NOTUSED
if ((strong_policy & POLICY_ACCESS_READ) &&
(arg->rda_common.ca_sig != (struct signature *) 0))
authenticated = 1;
#endif
/* entry has got a full list of attributes, eventually
select one required */
if (check_acl ((authtype % 3) >= authp ? binddn : NULLDN, ACL_READ,
entryptr->e_acl->ac_entry, realtarget) == NOTOK) {
if (dsp && (check_acl (binddn,ACL_READ,entryptr->e_acl->ac_entry, realtarget) == OK)) {
error->dse_type = DSE_SECURITYERROR;
error->ERR_SECURITY.DSE_sc_problem = DSE_SC_AUTHENTICATION;
dn_free (realtarget);
return (DS_ERROR_REMOTE);
} else {
error->dse_type = DSE_SECURITYERROR;
error->ERR_SECURITY.DSE_sc_problem = DSE_SC_ACCESSRIGHTS;
dn_free (realtarget);
return (DS_ERROR_REMOTE);
}
}
if (entryptr->e_dsainfo && need_pseudo_dsa(entryptr,arg)) {
/* Its a 7.0 or better DSA.
* pseudo attributes asked for.
* special routing req'd
*/
if (dn_cmp (realtarget, mydsadn) == 0) {
/* Its me - generate result */
if ((result->rdr_entry.ent_attr = dsa_eis_select (
arg->rda_eis,entryptr, dsp ? NULLDN : binddn,
quipu_ctx, realtarget)) != NULLATTR)
goto out;
if ( arg->rda_eis.eis_allattributes || arg->rda_eis.eis_select == NULLATTR)
goto out;
error->dse_type = DSE_ATTRIBUTEERROR;
error->ERR_ATTRIBUTE.DSE_at_name = get_copy_dn (entryptr);
error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_what =DSE_AT_NOSUCHATTRIBUTE;
error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_type = AttrT_cpy(arg->rda_eis.eis_select->attr_type);
error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_value = NULLAttrV;
error->ERR_ATTRIBUTE.DSE_at_plist.dse_at_next = DSE_AT_NOPROBLEM;
dn_free (realtarget);
return (DS_ERROR_REMOTE);
} else {
/* make referral to DSA in this entry */
(*di_p) = di_alloc();
(*di_p)->di_type = DI_TASK;
(*di_p)->di_dn = realtarget;
(*di_p)->di_target = dn_cpy(realtarget);
(*di_p)->di_reftype = RT_UNDEFINED;
(*di_p)->di_rdn_resolved = CR_RDNRESOLVED_NOTDEFINED;
(*di_p)->di_aliasedRDNs = CR_NOALIASEDRDNS;
(*di_p)->di_entry = entryptr;
entryptr->e_refcount++;
(*di_p)->di_state = DI_COMPLETE;
return DS_CONTINUE;
}
}
if (cant_use_cache (entryptr,binddn,arg->rda_eis,realtarget)) {
int res = referral_dsa_info(realtarget,NULLDNSEQ,FALSE,entryptr,error,di_p,
arg->rda_common.ca_servicecontrol.svc_options & SVC_OPT_PREFERCHAIN);
dn_free (realtarget);
return res;
}
if (dsp && (eis_check (arg->rda_eis,entryptr, binddn) != OK)) {
/* Can only send public things over DSP - but user is entitled to more */
error->dse_type = DSE_SECURITYERROR;
error->ERR_SECURITY.DSE_sc_problem = DSE_SC_AUTHENTICATION;
dn_free (realtarget);
return (DS_ERROR_REMOTE);
}
if ((result->rdr_entry.ent_attr = eis_select (arg->rda_eis,entryptr, dsp ? NULLDN : binddn, quipu_ctx, realtarget)) == NULLATTR)
if ( !arg->rda_eis.eis_allattributes && arg->rda_eis.eis_select != NULLATTR) {
error->dse_type = DSE_ATTRIBUTEERROR;
error->ERR_ATTRIBUTE.DSE_at_name = get_copy_dn (entryptr);
error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_what =DSE_AT_NOSUCHATTRIBUTE;
error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_type = AttrT_cpy(arg->rda_eis.eis_select->attr_type);
error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_value = NULLAttrV;
error->ERR_ATTRIBUTE.DSE_at_plist.dse_at_next = DSE_AT_NOPROBLEM;
dn_free (realtarget);
return (DS_ERROR_REMOTE);
}
out:
;
result->rdr_entry.ent_dn = realtarget;
result->rdr_entry.ent_iscopy = entryptr->e_data;
result->rdr_entry.ent_age = (time_t) 0;
result->rdr_entry.ent_next = NULLENTRYINFO;
result->rdr_common.cr_requestor = NULLDN;
/* if no error and NOT SVC_OPT_DONTDEREFERENCEALIASES then */
/* the alias will have been derefeferenced -signified by */
/* NO_ERROR !!! */
result->rdr_common.cr_aliasdereferenced = (error->dse_type == DSE_NOERROR) ? FALSE : TRUE;
return (DS_OK);
}
/*
* -----------------------------------------------
* Find command in command table
*
* Arguments:
* str - command string
*
* Return:
* if found, index into command table array,
* else -1
* -----------------------------------------------
*/
int find_verb(char *str)
{
return (find_entry(str, cmd_ary));
}
/**
* Send an ARP request for the given IP address and/or queue a packet.
*
* If the IP address was not yet in the cache, a pending ARP cache entry
* is added and an ARP request is sent for the given address. The packet
* is queued on this entry.
*
* If the IP address was already pending in the cache, a new ARP request
* is sent for the given address. The packet is queued on this entry.
*
* If the IP address was already stable in the cache, and a packet is
* given, it is directly sent and no ARP request is sent out.
*
* If the IP address was already stable in the cache, and no packet is
* given, an ARP request is sent out.
*
* @param netif The lwIP network interface on which ipaddr
* must be queried for.
* @param ipaddr The IP address to be resolved.
* @param q If non-NULL, a pbuf that must be delivered to the IP address.
* q is not freed by this function.
*
* @return
* - ERR_BUF Could not make room for Ethernet header.
* - ERR_MEM Hardware address unknown, and no more ARP entries available
* to query for address or queue the packet.
* - ERR_MEM Could not queue packet due to memory shortage.
* - ERR_RTE No route to destination (no gateway to external networks).
* - ERR_ARG Non-unicast address given, those will not appear in ARP cache.
*
*/
err_t etharp_query(struct netif *netif, struct ip_addr *ipaddr, struct pbuf *q)
{
struct eth_addr * srcaddr = (struct eth_addr *)netif->hwaddr;
err_t result = ERR_MEM;
s8_t i; /* ARP entry index */
u8_t k; /* Ethernet address octet index */
/* non-unicast address? */
if (ip_addr_isbroadcast(ipaddr, netif) ||
ip_addr_ismulticast(ipaddr) ||
ip_addr_isany(ipaddr)) {
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: will not add non-unicast IP address to ARP cache\n"));
return ERR_ARG;
}
/* find entry in ARP cache, ask to create entry if queueing packet */
i = find_entry(ipaddr, ETHARP_TRY_HARD);
/* could not find or create entry? */
if (i < 0)
{
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: could not create ARP entry\n"));
if (q) LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: packet dropped\n"));
return (err_t)i;
}
/* mark a fresh entry as pending (we just sent a request) */
if (arp_table[i].state == ETHARP_STATE_EMPTY) {
arp_table[i].state = ETHARP_STATE_PENDING;
}
/* { i is either a STABLE or (new or existing) PENDING entry } */
LWIP_ASSERT("arp_table[i].state == PENDING or STABLE",
((arp_table[i].state == ETHARP_STATE_PENDING) ||
(arp_table[i].state == ETHARP_STATE_STABLE)));
/* do we have a pending entry? or an implicit query request? */
if ((arp_table[i].state == ETHARP_STATE_PENDING) || (q == NULL)) {
/* try to resolve it; send out ARP request */
result = etharp_request(netif, ipaddr);
}
/* packet given? */
if (q != NULL) {
/* stable entry? */
if (arp_table[i].state == ETHARP_STATE_STABLE) {
/* we have a valid IP->Ethernet address mapping,
* fill in the Ethernet header for the outgoing packet */
struct eth_hdr *ethhdr = q->payload;
for(k = 0; k < netif->hwaddr_len; k++) {
ethhdr->dest.addr[k] = arp_table[i].ethaddr.addr[k];
ethhdr->src.addr[k] = srcaddr->addr[k];
}
ethhdr->type = htons(ETHTYPE_IP);
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: sending packet %p\n", (void *)q));
/* send the packet */
result = netif->linkoutput(netif, q);
/* pending entry? (either just created or already pending */
} else if (arp_table[i].state == ETHARP_STATE_PENDING) {
#if ARP_QUEUEING /* queue the given q packet */
struct pbuf *p;
/* copy any PBUF_REF referenced payloads into PBUF_RAM */
/* (the caller of lwIP assumes the referenced payload can be
* freed after it returns from the lwIP call that brought us here) */
p = pbuf_take(q);
/* packet could be taken over? */
if (p != NULL) {
/* queue packet ... */
if (arp_table[i].p == NULL) {
/* ... in the empty queue */
pbuf_ref(p);
arp_table[i].p = p;
#if 0 /* multi-packet-queueing disabled, see bug #11400 */
} else {
/* ... at tail of non-empty queue */
pbuf_queue(arp_table[i].p, p);
#endif
}
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: queued packet %p on ARP entry %"S16_F"\n", (void *)q, (s16_t)i));
result = ERR_OK;
} else {
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n", (void *)q));
/* { result == ERR_MEM } through initialization */
}
#else /* ARP_QUEUEING == 0 */
/* q && state == PENDING && ARP_QUEUEING == 0 => result = ERR_MEM */
/* { result == ERR_MEM } through initialization */
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("etharp_query: Ethernet destination address unknown, queueing disabled, packet %p dropped\n", (void *)q));
#endif
}
}
return result;
}
bool
find_rttables_table(const char *name, uint32_t *id)
{
return find_entry(name, id, &rt_tables, RT_TABLES_FILE, rttable_default, RT_TABLE_MAX);
}
gboolean
is_store_add_sensor(IsStore *self,
IsSensor *sensor,
GtkTreeIter *iter)
{
IsStorePrivate *priv;
GSequence *entries;
IsStoreEntry *entry = NULL;
GSequenceIter *parent = NULL;
gchar **names = NULL;
int i;
GtkTreePath *path;
GtkTreeIter _iter;
gboolean ret = FALSE;
g_return_val_if_fail(IS_IS_STORE(self), FALSE);
g_return_val_if_fail(IS_IS_SENSOR(sensor), FALSE);
priv = self->priv;
entry = find_entry(self, is_sensor_get_path(sensor));
if (entry) {
is_warning("store", "sensor %s already exists in store, not adding duplicate",
is_sensor_get_path(sensor));
goto out;
}
entries = priv->entries;
names = g_strsplit(is_sensor_get_path(sensor), "/", 0);
/* otherwise iterate through to create the entry */
for (i = 0; names[i] != NULL; i++) {
GSequenceIter *seq_iter;
gchar *name = names[i];
entry = NULL;
for (seq_iter = g_sequence_get_begin_iter(entries);
!g_sequence_iter_is_end(seq_iter);
seq_iter = g_sequence_iter_next(seq_iter))
{
entry = (IsStoreEntry *)g_sequence_get(seq_iter);
if (g_strcmp0(entry->name, name) == 0) {
entries = entry->entries;
parent = seq_iter;
break;
}
entry = NULL;
}
if (!entry) {
/* create entry for this name component */
entry = entry_new(name);
entry->iter = g_sequence_append(entries, entry);
entry->parent = parent;
entries = entry->entries;
_iter.stamp = priv->stamp;
_iter.user_data = entry->iter;
path = gtk_tree_model_get_path(GTK_TREE_MODEL(self),
&_iter);
gtk_tree_model_row_inserted(GTK_TREE_MODEL(self), path,
&_iter);
gtk_tree_path_free(path);
/* parent of the next entry we create will be this
* entry */
parent = entry->iter;
}
}
g_strfreev(names);
g_assert(entry);
g_assert(find_entry(self, is_sensor_get_path(sensor)) == entry);
is_debug("store", "inserted sensor %s with label %s",
is_sensor_get_path(sensor), is_sensor_get_label(sensor));
entry->sensor = g_object_ref(sensor);
_iter.stamp = priv->stamp;
_iter.user_data = entry->iter;
path = gtk_tree_model_get_path(GTK_TREE_MODEL(self),
&_iter);
gtk_tree_model_row_changed(GTK_TREE_MODEL(self), path,
&_iter);
gtk_tree_path_free(path);
/* return a copy of iter */
if (iter != NULL) {
iter->stamp = priv->stamp;
iter->user_data = entry->iter;
}
ret = TRUE;
out:
return ret;
}
bool
find_rttables_group(const char *name, uint32_t *id)
{
return find_entry(name, id, &rt_groups, RT_GROUPS_FILE, NULL, INT32_MAX);
}
void* ThreadCookieManager::get(Thread* t) {
TCEntry* entry = find_entry(t);
return (entry != NULL) ? entry->_cookie : NULL;
}
bool
find_rttables_realms(const char *name, uint32_t *id)
{
return find_entry(name, id, &rt_realms, RT_REALMS_FILE, NULL, 255);
}
int
parameter_flashfs_write(flash_file_token_t token, uint8_t *buffer, size_t buf_size)
{
int rv = -ENXIO;
if (sector_map) {
rv = 0;
/* Calculate the total space needed */
size_t total_size = buf_size + sizeof(flash_entry_header_t);
size_t alignment = sizeof(h_magic_t) - 1;
size_t size_adjust = ((total_size + alignment) & ~alignment) - total_size;
total_size += size_adjust;
/* Is this and existing entry */
flash_entry_header_t *pf = find_entry(token);
if (!pf) {
/* No Entry exists for this token so find a place for it */
pf = find_free(total_size);
/* No Space */
if (pf == 0) {
return -ENOSPC;
}
} else {
/* Do we have space after the entry in the sector for the update */
sector_descriptor_t *current_sector = check_free_space_in_sector(pf,
total_size);
if (current_sector == 0) {
/* Mark the last entry erased */
/* todo:consider a 2 stage erase or write before erase and do a fs check
* at start up
*/
rv = erase_entry(pf);
if (rv < 0) {
return rv;
}
/* We had space and marked the last entry erased so use the Next Free */
pf = next_entry(pf);
} else {
/*
* We did not have space in the current sector so select the next sector
*/
current_sector = get_next_sector_descriptor(current_sector);
/* Will the data fit */
if (current_sector->size < total_size) {
return -ENOSPC;
}
/* Mark the last entry erased */
/* todo:consider a 2 stage erase or write before erase and do a fs check
* at start up
*/
rv = erase_entry(pf);
if (rv < 0) {
return rv;
}
pf = (flash_entry_header_t *) current_sector->address;
}
if (!blank_check(pf, total_size)) {
rv = erase_sector(current_sector, pf);
}
}
flash_entry_header_t *pn = (flash_entry_header_t *)(buffer - sizeof(flash_entry_header_t));
pn->magic = MagicSig;
pn->file_token.t = token.t;
pn->flag = ValidEntry + size_adjust;
pn->size = total_size;
for (size_t a = 0; a < size_adjust; a++) {
buffer[buf_size + a] = (uint8_t)BlankSig;
}
pn->crc = crc32(entry_crc_start(pn), entry_crc_length(pn));
rv = up_progmem_write((size_t) pf, pn, pn->size);
int system_bytes = (sizeof(flash_entry_header_t) + size_adjust);
if (rv >= system_bytes) {
rv -= system_bytes;
}
}
return rv;
}
void
tk_archive_entry_linkify(struct archive_entry_linkresolver *res,
struct archive_entry **e, struct archive_entry **f)
{
struct links_entry *le;
struct archive_entry *t;
*f = NULL; /* Default: Don't return a second entry. */
if (*e == NULL) {
le = next_entry(res);
if (le != NULL) {
*e = le->entry;
le->entry = NULL;
}
return;
}
/* If it has only one link, then we're done. */
if (tk_archive_entry_nlink(*e) == 1)
return;
/* Directories, devices never have hardlinks. */
if (tk_archive_entry_filetype(*e) == AE_IFDIR
|| tk_archive_entry_filetype(*e) == AE_IFBLK
|| tk_archive_entry_filetype(*e) == AE_IFCHR)
return;
switch (res->strategy) {
case ARCHIVE_ENTRY_LINKIFY_LIKE_TAR:
le = find_entry(res, *e);
if (le != NULL) {
tk_archive_entry_unset_size(*e);
tk_archive_entry_copy_hardlink(*e,
tk_archive_entry_pathname(le->canonical));
} else
insert_entry(res, *e);
return;
case ARCHIVE_ENTRY_LINKIFY_LIKE_MTREE:
le = find_entry(res, *e);
if (le != NULL) {
tk_archive_entry_copy_hardlink(*e,
tk_archive_entry_pathname(le->canonical));
} else
insert_entry(res, *e);
return;
case ARCHIVE_ENTRY_LINKIFY_LIKE_OLD_CPIO:
/* This one is trivial. */
return;
case ARCHIVE_ENTRY_LINKIFY_LIKE_NEW_CPIO:
le = find_entry(res, *e);
if (le != NULL) {
/*
* Put the new entry in le, return the
* old entry from le.
*/
t = *e;
*e = le->entry;
le->entry = t;
/* Make the old entry into a hardlink. */
tk_archive_entry_unset_size(*e);
tk_archive_entry_copy_hardlink(*e,
tk_archive_entry_pathname(le->canonical));
/* If we ran out of links, return the
* final entry as well. */
if (le->links == 0) {
*f = le->entry;
le->entry = NULL;
}
} else {
/*
* If we haven't seen it, tuck it away
* for future use.
*/
le = insert_entry(res, *e);
le->entry = *e;
*e = NULL;
}
return;
default:
break;
}
return;
}
void datamap_set_float_format(datamap *map, int dlgitem, const char *format)
{
datamap_entry *entry = find_entry(map, dlgitem);
entry->float_format = format;
}
compat_fd compat_file_open(const char *path, int write)
{
if (write)
{
log_cb(RETRO_LOG_ERROR, "Cannot open \"%s\" for writing\n", path);
return COMPAT_FILE_OPEN_FAILED;
}
compat_fd_internal *fd = (compat_fd_internal*)malloc(sizeof(compat_fd_internal));
if (!fd)
{
log_cb(RETRO_LOG_ERROR, "Out of memory while opening \"%s\"\n", path);
return COMPAT_FILE_OPEN_FAILED;
}
const entry_t* entry = find_entry(path);
if (entry != NULL)
{
fd->ptr = (const char*)entry->ptr;
fd->length = fd->remain = entry->size;
log_cb(RETRO_LOG_INFO, "Opened \"%s\" from memory\n", path);
return (compat_fd)fd;
}
log_cb(RETRO_LOG_INFO, "Could not find file \"%s\", trying file system\n", path);
const char *sys;
if (!env_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &sys) || !sys)
{
log_cb(RETRO_LOG_ERROR, "Error getting the system folder while opening \"%s\"\n", path);
free(fd);
return COMPAT_FILE_OPEN_FAILED;
}
char system[MAX_PATH_LEN];
strncpy(system, sys, MAX_PATH_LEN);
system[MAX_PATH_LEN - 1] = 0;
strncat(system, "/fuse", MAX_PATH_LEN);
system[MAX_PATH_LEN - 1] = 0;
strncat(system, path, MAX_PATH_LEN);
system[MAX_PATH_LEN - 1] = 0;
log_cb(RETRO_LOG_INFO, "Trying to open \"%s\" from the file system\n", system);
FILE* file = fopen(system, "rb");
if (!file)
{
log_cb(RETRO_LOG_ERROR, "Could not find file \"%s\" on the file system\n", system);
free(fd);
return COMPAT_FILE_OPEN_FAILED;
}
long size;
if (fseek(file, 0, SEEK_END) != 0 || (size = ftell(file)) < 0 || fseek(file, 0, SEEK_SET) != 0)
{
log_cb(RETRO_LOG_ERROR, "Could not determine size of \"%s\"\n", system);
fclose(file);
free(fd);
return COMPAT_FILE_OPEN_FAILED;
}
void* ptr = malloc(size);
if (!ptr)
{
log_cb(RETRO_LOG_ERROR, "Out of memory while opening \"%s\"\n", system);
fclose(file);
free(fd);
return COMPAT_FILE_OPEN_FAILED;
}
if (fread(ptr, 1, size, file) != size)
{
log_cb(RETRO_LOG_ERROR, "Error reading from \"%s\"\n", system);
free(ptr);
fclose(file);
free(fd);
return COMPAT_FILE_OPEN_FAILED;
}
fclose(file);
fd->ptr = (const char*)ptr;
fd->length = fd->remain = size;
log_cb(RETRO_LOG_INFO, "Opened \"%s\" from the file system\n", system);
return (compat_fd)fd;
}
void datamap_populate_control(datamap *map, HWND dialog, windows_options &opts, int dlgitem)
{
datamap_entry *entry = find_entry(map, dlgitem);
control_operation(map, dialog, &opts, entry, DCT_POPULATE_CONTROL);
}
/**
* Update (or insert) a IP/MAC address pair in the ARP cache.
*
* If a pending entry is resolved, any queued packets will be sent
* at this point.
*
* @param ipaddr IP address of the inserted ARP entry.
* @param ethaddr Ethernet address of the inserted ARP entry.
* @param flags Defines behaviour:
* - ETHARP_TRY_HARD Allows ARP to insert this as a new item. If not specified,
* only existing ARP entries will be updated.
*
* @return
* - ERR_OK Succesfully updated ARP cache.
* - ERR_MEM If we could not add a new ARP entry when ETHARP_TRY_HARD was set.
* - ERR_ARG Non-unicast address given, those will not appear in ARP cache.
*
* @see pbuf_free()
*/
static err_t
update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *ethaddr, u8_t flags)
{
s8_t i;
u8_t k;
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE | 3, ("update_arp_entry()\n"));
LWIP_ASSERT("netif->hwaddr_len != 0", netif->hwaddr_len != 0);
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F" - %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F"\n",
ip4_addr1(ipaddr), ip4_addr2(ipaddr), ip4_addr3(ipaddr), ip4_addr4(ipaddr),
ethaddr->addr[0], ethaddr->addr[1], ethaddr->addr[2],
ethaddr->addr[3], ethaddr->addr[4], ethaddr->addr[5]));
/* non-unicast address? */
if (ip_addr_isany(ipaddr) ||
ip_addr_isbroadcast(ipaddr, netif) ||
ip_addr_ismulticast(ipaddr)) {
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: will not add non-unicast IP address to ARP cache\n"));
return ERR_ARG;
}
/* find or create ARP entry */
i = find_entry(ipaddr, flags);
/* bail out if no entry could be found */
if (i < 0) return (err_t)i;
/* mark it stable */
arp_table[i].state = ETHARP_STATE_STABLE;
/* record network interface */
arp_table[i].netif = netif;
/* insert in SNMP ARP index tree */
snmp_insert_arpidx_tree(netif, &arp_table[i].ipaddr);
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: updating stable entry %"S16_F"\n", (s16_t)i));
/* update address */
k = netif->hwaddr_len;
while (k > 0) {
k--;
arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];
}
/* reset time stamp */
arp_table[i].ctime = 0;
/* this is where we will send out queued packets! */
#if ARP_QUEUEING
while (arp_table[i].p != NULL) {
/* get the first packet on the queue */
struct pbuf *p = arp_table[i].p;
/* Ethernet header */
struct eth_hdr *ethhdr = p->payload;
/* remember (and reference) remainder of queue */
/* note: this will also terminate the p pbuf chain */
arp_table[i].p = pbuf_dequeue(p);
/* fill-in Ethernet header */
k = netif->hwaddr_len;
while(k > 0) {
k--;
ethhdr->dest.addr[k] = ethaddr->addr[k];
ethhdr->src.addr[k] = netif->hwaddr[k];
}
ethhdr->type = htons(ETHTYPE_IP);
LWIP_DEBUGF(ETHARP_DEBUG | DBG_TRACE, ("update_arp_entry: sending queued IP packet %p.\n", (void *)p));
/* send the queued IP packet */
netif->linkoutput(netif, p);
/* free the queued IP packet */
pbuf_free(p);
}
#endif
return ERR_OK;
}
/**
* Update (or insert) a IP/MAC address pair in the ARP cache.
*
* If a pending entry is resolved, any queued packets will be sent
* at this point.
*
* @param ipaddr IP address of the inserted ARP entry.
* @param ethaddr Ethernet address of the inserted ARP entry.
* @param flags Defines behaviour:
* - ETHARP_TRY_HARD Allows ARP to insert this as a new item. If not specified,
* only existing ARP entries will be updated.
*
* @return
* - ERR_OK Succesfully updated ARP cache.
* - ERR_MEM If we could not add a new ARP entry when ETHARP_TRY_HARD was set.
* - ERR_ARG Non-unicast address given, those will not appear in ARP cache.
*
* @see pbuf_free()
*/
static err_t
update_arp_entry(struct netif *netif, struct ip_addr *ipaddr, struct eth_addr *ethaddr, u8_t flags)
{
s8_t i;
u8_t k;
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | 3, ("update_arp_entry()\n"));
LWIP_ASSERT("netif->hwaddr_len == ETHARP_HWADDR_LEN", netif->hwaddr_len == ETHARP_HWADDR_LEN);
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F" - %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F"\n",
ip4_addr1(ipaddr), ip4_addr2(ipaddr), ip4_addr3(ipaddr), ip4_addr4(ipaddr),
ethaddr->addr[0], ethaddr->addr[1], ethaddr->addr[2],
ethaddr->addr[3], ethaddr->addr[4], ethaddr->addr[5]));
/* non-unicast address? */
if (ip_addr_isany(ipaddr) ||
ip_addr_isbroadcast(ipaddr, netif) ||
ip_addr_ismulticast(ipaddr)) {
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: will not add non-unicast IP address to ARP cache\n"));
return ERR_ARG;
}
/* find or create ARP entry */
#if LWIP_NETIF_HWADDRHINT
i = find_entry(ipaddr, flags, netif);
#else /* LWIP_NETIF_HWADDRHINT */
i = find_entry(ipaddr, flags);
#endif /* LWIP_NETIF_HWADDRHINT */
/* bail out if no entry could be found */
if (i < 0)
return (err_t)i;
/* mark it stable */
arp_table[i].state = ETHARP_STATE_STABLE;
/* record network interface */
arp_table[i].netif = netif;
/* insert in SNMP ARP index tree */
snmp_insert_arpidx_tree(netif, &arp_table[i].ipaddr);
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: updating stable entry %"S16_F"\n", (s16_t)i));
/* update address */
k = ETHARP_HWADDR_LEN;
while (k > 0) {
k--;
arp_table[i].ethaddr.addr[k] = ethaddr->addr[k];
}
/* reset time stamp */
arp_table[i].ctime = 0;
#if ARP_QUEUEING
/* this is where we will send out queued packets! */
while (arp_table[i].q != NULL) {
struct pbuf *p;
/* remember remainder of queue */
struct etharp_q_entry *q = arp_table[i].q;
/* pop first item off the queue */
arp_table[i].q = q->next;
/* get the packet pointer */
p = q->p;
/* now queue entry can be freed */
memp_free(MEMP_ARP_QUEUE, q);
/* send the queued IP packet */
etharp_send_ip(netif, p, (struct eth_addr*)(netif->hwaddr), ethaddr);
/* free the queued IP packet */
pbuf_free(p);
}
#endif
return ERR_OK;
}
/**
* Update (or insert) a IP/MAC address pair in the ARP cache.
*
* If a pending entry is resolved, any queued packets will be sent
* at this point.
*
* @param netif netif related to this entry (used for NETIF_ADDRHINT)
* @param ipaddr IP address of the inserted ARP entry.
* @param ethaddr Ethernet address of the inserted ARP entry.
* @param flags @see definition of ETHARP_FLAG_*
*
* @return
* - ERR_OK Succesfully updated ARP cache.
* - ERR_MEM If we could not add a new ARP entry when ETHARP_FLAG_TRY_HARD was set.
* - ERR_ARG Non-unicast address given, those will not appear in ARP cache.
*
* @see pbuf_free()
*/
static err_t
update_arp_entry(struct netif *netif, ip_addr_t *ipaddr, struct eth_addr *ethaddr, u8_t flags)
{
s8_t i;
LWIP_ASSERT("netif->hwaddr_len == ETHARP_HWADDR_LEN", netif->hwaddr_len == ETHARP_HWADDR_LEN);
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F" - %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F"\n",
ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr),
ethaddr->addr[0], ethaddr->addr[1], ethaddr->addr[2],
ethaddr->addr[3], ethaddr->addr[4], ethaddr->addr[5]));
/* non-unicast address? */
if (ip_addr_isany(ipaddr) ||
ip_addr_isbroadcast(ipaddr, netif) ||
ip_addr_ismulticast(ipaddr)) {
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: will not add non-unicast IP address to ARP cache\n"));
return (ERR_ARG);
}
/* find or create ARP entry */
i = find_entry(ipaddr, flags);
/* bail out if no entry could be found */
if (i < 0) {
return (err_t)i;
}
#if ETHARP_SUPPORT_STATIC_ENTRIES
if (flags & ETHARP_FLAG_STATIC_ENTRY) {
/* record static type */
arp_table[i].static_entry = 1;
}
#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
/* mark it stable */
arp_table[i].state = ETHARP_STATE_STABLE;
#if LWIP_SNMP
/* record network interface */
arp_table[i].netif = netif;
#endif /* LWIP_SNMP */
/* insert in SNMP ARP index tree */
snmp_insert_arpidx_tree(netif, &arp_table[i].ipaddr);
LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("update_arp_entry: updating stable entry %"S16_F"\n", (s16_t)i));
/* update address */
ETHADDR32_COPY(&arp_table[i].ethaddr, ethaddr);
/* reset time stamp */
arp_table[i].ctime = 0;
#if ARP_QUEUEING
/* this is where we will send out queued packets! */
while (arp_table[i].q != NULL) {
struct pbuf *p;
/* remember remainder of queue */
struct etharp_q_entry *q = arp_table[i].q;
/* pop first item off the queue */
arp_table[i].q = q->next;
/* get the packet pointer */
p = q->p;
/* now queue entry can be freed */
memp_free(MEMP_ARP_QUEUE, q);
/* send the queued IP packet */
etharp_send_ip(netif, p, (struct eth_addr*)(netif->hwaddr), ethaddr);
/* free the queued IP packet */
pbuf_free(p);
}
#endif /* ARP_QUEUEING */
return (ERR_OK);
}
