/*
* Dynamically allocate space for a struct item plus the key and data
* elements. If name is non-NULL it is used as the key, else the
* gid is the key. Fills in datum from struct group.
*/
struct cache_item *
make_gritem(const struct group *gr, const char *name)
{
char *cp;
size_t nsize, psize, nmem, total, len;
struct cache_item *item;
struct group *newgr;
/* Allocate in one big chunk for easy freeing. */
nsize = psize = nmem = 0;
total = sizeof(struct cache_item) + sizeof(struct group);
FIELD_SIZE(gr, gr_name, nsize);
FIELD_SIZE(gr, gr_passwd, psize);
if (gr->gr_mem) {
for (nmem = 0; gr->gr_mem[nmem] != NULL; nmem++)
total += strlen(gr->gr_mem[nmem]) + 1;
nmem++;
total += sizeof(char *) * nmem;
}
if (name != NULL)
total += strlen(name) + 1;
if ((item = malloc(total)) == NULL)
return NULL;
cp = (char *) item + sizeof(struct cache_item);
/*
* Copy in group contents and make strings relative to space
* at the end of the buffer. Note that gr_mem must come
* immediately after struct group to guarantee proper alignment.
*/
newgr = (struct group *)cp;
memcpy(newgr, gr, sizeof(struct group));
cp += sizeof(struct group);
if (gr->gr_mem) {
newgr->gr_mem = (char **)cp;
cp += sizeof(char *) * nmem;
for (nmem = 0; gr->gr_mem[nmem] != NULL; nmem++) {
len = strlen(gr->gr_mem[nmem]) + 1;
memcpy(cp, gr->gr_mem[nmem], len);
newgr->gr_mem[nmem] = cp;
cp += len;
}
newgr->gr_mem[nmem] = NULL;
}
FIELD_COPY(gr, newgr, gr_passwd, psize);
FIELD_COPY(gr, newgr, gr_name, nsize);
/* Set key and datum. */
if (name != NULL) {
memcpy(cp, name, strlen(name) + 1);
item->k.name = cp;
} else {
item->k.gid = gr->gr_gid;
}
item->d.gr = newgr;
item->refcnt = 1;
return item;
}
LOCAL cl_int
cl_get_image_info(cl_mem mem,
cl_image_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret)
{
int err;
CHECK_IMAGE(mem, image);
switch(param_name)
{
FIELD_SIZE(IMAGE_FORMAT, cl_image_format);
FIELD_SIZE(IMAGE_ELEMENT_SIZE, size_t);
FIELD_SIZE(IMAGE_ROW_PITCH, size_t);
FIELD_SIZE(IMAGE_SLICE_PITCH, size_t);
FIELD_SIZE(IMAGE_WIDTH, size_t);
FIELD_SIZE(IMAGE_HEIGHT, size_t);
FIELD_SIZE(IMAGE_DEPTH, size_t);
default:
return CL_INVALID_VALUE;
}
switch(param_name)
{
case CL_IMAGE_FORMAT:
*(cl_image_format *)param_value = image->fmt;
break;
case CL_IMAGE_ELEMENT_SIZE:
*(size_t *)param_value = image->bpp;
break;
case CL_IMAGE_ROW_PITCH:
*(size_t *)param_value = image->row_pitch;
break;
case CL_IMAGE_SLICE_PITCH:
*(size_t *)param_value = image->slice_pitch;
break;
case CL_IMAGE_WIDTH:
*(size_t *)param_value = image->w;
break;
case CL_IMAGE_HEIGHT:
*(size_t *)param_value = image->h;
break;
case CL_IMAGE_DEPTH:
*(size_t *)param_value = image->depth;
break;
}
return CL_SUCCESS;
error:
return err;
}
LOCAL cl_int
cl_get_mem_object_info(cl_mem mem,
cl_mem_info param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret)
{
switch(param_name)
{
FIELD_SIZE(MEM_TYPE, cl_mem_object_type);
FIELD_SIZE(MEM_FLAGS, cl_mem_flags);
FIELD_SIZE(MEM_SIZE, size_t);
FIELD_SIZE(MEM_HOST_PTR, void *);
FIELD_SIZE(MEM_MAP_COUNT, cl_uint);
FIELD_SIZE(MEM_REFERENCE_COUNT, cl_uint);
FIELD_SIZE(MEM_CONTEXT, cl_context);
FIELD_SIZE(MEM_ASSOCIATED_MEMOBJECT, cl_mem);
FIELD_SIZE(MEM_OFFSET, size_t);
default:
return CL_INVALID_VALUE;
}
switch(param_name)
{
case CL_MEM_TYPE:
*((cl_mem_object_type *)param_value) = cl_get_mem_object_type(mem);
break;
case CL_MEM_FLAGS:
*((cl_mem_flags *)param_value) = mem->flags;
break;
case CL_MEM_SIZE:
*((size_t *)param_value) = mem->size;
break;
case CL_MEM_HOST_PTR:
*((size_t *)param_value) = (size_t)mem->host_ptr;
break;
case CL_MEM_MAP_COUNT:
*((cl_uint *)param_value) = mem->map_ref;
break;
case CL_MEM_REFERENCE_COUNT:
*((cl_uint *)param_value) = mem->ref_n;
break;
case CL_MEM_CONTEXT:
*((cl_context *)param_value) = mem->ctx;
break;
case CL_MEM_ASSOCIATED_MEMOBJECT:
if(mem->type != CL_MEM_SUBBUFFER_TYPE) {
*((cl_mem *)param_value) = NULL;
} else {
struct _cl_mem_buffer* buf = (struct _cl_mem_buffer*)mem;
*((cl_mem *)param_value) = (cl_mem)(buf->parent);
}
break;
case CL_MEM_OFFSET:
if(mem->type != CL_MEM_SUBBUFFER_TYPE) {
*((size_t *)param_value) = 0;
} else {
struct _cl_mem_buffer* buf = (struct _cl_mem_buffer*)mem;
*((size_t *)param_value) = buf->sub_offset;
}
break;
}
return CL_SUCCESS;
}
/*
* Dynamically allocate space for a struct item plus the key and data
* elements. If name is non-NULL it is used as the key, else the
* uid is the key. Fills in datum from struct password.
*/
static struct cache_item *
make_pwitem(const struct passwd *pw, const char *name)
{
char *cp;
const char *pw_shell;
size_t nsize, psize, csize, gsize, dsize, ssize, total;
struct cache_item_pw *pwitem;
struct passwd *newpw;
debug_decl(make_pwitem, SUDO_DEBUG_NSS)
/* If shell field is empty, expand to _PATH_BSHELL. */
pw_shell = (pw->pw_shell == NULL || pw->pw_shell[0] == '\0')
? _PATH_BSHELL : pw->pw_shell;
/* Allocate in one big chunk for easy freeing. */
nsize = psize = csize = gsize = dsize = ssize = 0;
total = sizeof(*pwitem);
FIELD_SIZE(pw, pw_name, nsize);
FIELD_SIZE(pw, pw_passwd, psize);
#ifdef HAVE_LOGIN_CAP_H
FIELD_SIZE(pw, pw_class, csize);
#endif
FIELD_SIZE(pw, pw_gecos, gsize);
FIELD_SIZE(pw, pw_dir, dsize);
/* Treat shell specially since we expand "" -> _PATH_BSHELL */
ssize = strlen(pw_shell) + 1;
total += ssize;
if (name != NULL)
total += strlen(name) + 1;
/* Allocate space for struct item, struct passwd and the strings. */
pwitem = ecalloc(1, total);
newpw = &pwitem->pw;
/*
* Copy in passwd contents and make strings relative to space
* at the end of the struct.
*/
memcpy(newpw, pw, sizeof(*pw));
cp = (char *)(pwitem + 1);
FIELD_COPY(pw, newpw, pw_name, nsize);
FIELD_COPY(pw, newpw, pw_passwd, psize);
#ifdef HAVE_LOGIN_CAP_H
FIELD_COPY(pw, newpw, pw_class, csize);
#endif
FIELD_COPY(pw, newpw, pw_gecos, gsize);
FIELD_COPY(pw, newpw, pw_dir, dsize);
/* Treat shell specially since we expand "" -> _PATH_BSHELL */
memcpy(cp, pw_shell, ssize);
newpw->pw_shell = cp;
cp += ssize;
/* Set key and datum. */
if (name != NULL) {
memcpy(cp, name, strlen(name) + 1);
pwitem->cache.k.name = cp;
} else {
pwitem->cache.k.uid = pw->pw_uid;
}
pwitem->cache.d.pw = newpw;
pwitem->cache.refcnt = 1;
debug_return_ptr(&pwitem->cache);
}
*
* History:
* 15-Dec-1993 JohnC Pulled functions from user\server.
\***************************************************************************/
#include "precomp.h"
#pragma hdrstop
/*
* These arrays are used by GetClassWord/Long.
*/
// !!! can't we get rid of this and just special case GCW_ATOM
CONST BYTE afClassDWord[] = {
FIELD_SIZE(CLS, spicnSm), // GCL_HICONSM (-34)
0,
FIELD_SIZE(CLS, atomClassName), // GCW_ATOM (-32)
0,
0,
0,
0,
0,
FIELD_SIZE(CLS, style), // GCL_STYLE (-26)
0,
FIELD_SIZE(CLS, lpfnWndProc), // GCL_WNDPROC (-24)
0,
0,
0,
FIELD_SIZE(CLS, cbclsExtra), // GCL_CBCLSEXTRA (-20)
0,
/**
* Handle adding a class type.
*
* @param df The debug file to add information to.
* @param cl The class to add to the debugging file.
*/
static void dfHandleClass(struct debug_file *df, struct Hjava_lang_Class *cl)
{
int lpc;
assert(df != NULL);
assert(cl != NULL);
/* Allocate a type id if necessary. */
if( cl->stab_id == 0 )
{
cl->stab_id = df->df_current_type_id + 1;
df->df_current_type_id += 2;
}
/* Add the structure type, */
fmanglef(df->df_file,
".stabs \"%t",
"/", ".", cl->name->data);
if( cl->loader != NULL )
{
fmanglef(df->df_file,
"_%p",
cl->loader);
}
fprintf(df->df_file,
":T%d=s%d",
cl->stab_id - 1,
CLASS_FSIZE(cl));
/* ... fill in the base fields/class, */
if( cl->superclass == NULL )
{
fprintf(df->df_file,
"vtable:%d,%d,%d;",
STYPE_DISPATCH_TABLE,
0,
sizeof(dispatchTable *) * 8);
fprintf(df->df_file,
"_$lock:%d,%d,%d;",
STYPE_ILOCK,
sizeof(dispatchTable *) * 8,
sizeof(iLock *) * 8);
}
else
{
fprintf(df->df_file,
"!1,020,%d;",
cl->superclass->stab_id - 1);
}
/* ... fill in the instance fields, */
for( lpc = 0; lpc < CLASS_NIFIELDS(cl); lpc++ )
{
fields *fld = CLASS_IFIELDS(cl);
struct Hjava_lang_Class *ftype;
if( (ftype = FIELD_TYPE(&fld[lpc])) != NULL )
{
fprintf(df->df_file,
"%s:/%d%d,%d,%d;",
fld[lpc].name->data,
acc2prot(fld[lpc].accflags),
ftype->stab_id,
FIELD_BOFFSET(&fld[lpc]) * 8,
FIELD_SIZE(&fld[lpc]) * 8);
}
}
/* ... the static fields, and */
for( lpc = 0; lpc < CLASS_NSFIELDS(cl); lpc++ )
{
fields *fld = CLASS_SFIELDS(cl);
struct Hjava_lang_Class *ftype;
if( (ftype = FIELD_TYPE(&fld[lpc])) != NULL )
{
fprintf(df->df_file,
"%s:/%d%d:",
fld[lpc].name->data,
acc2prot(fld[lpc].accflags),
ftype->stab_id);
fmanglef(df->df_file,
"_ZN%q%d%sE;",
df_quals, cl->name->data, cl->loader,
strlen(fld[lpc].name->data),
fld[lpc].name->data);
}
}
/* ... the synthetic 'class' static member. */
fmanglef(df->df_file,
"class:xsHjava_lang_Class:"
":_ZN%q%d%sE;",
df_quals, cl->name->data, cl->loader,
strlen("class"),
"class");
fprintf(df->df_file, ";\",%d,0,0,0\n", N_LSYM);
/* Add a typedef and */
fmanglef(df->df_file,
".stabs \"%t",
"/", ".", cl->name->data);
if( cl->loader != NULL )
{
fprintf(df->df_file, "_%p", cl->loader);
}
fprintf(df->df_file,
":t%d\",%d,0,0,0\n",
cl->stab_id - 1,
N_LSYM);
/* ... an anonymous pointer type. */
fprintf(df->df_file,
".stabs \" :%d=*%d\",%d,0,0,0\n",
cl->stab_id,
cl->stab_id - 1,
N_LSYM);
/* Add symbols and their values. */
for( lpc = 0; lpc < CLASS_NSFIELDS(cl); lpc++ )
{
fields *fld = CLASS_SFIELDS(cl);
struct Hjava_lang_Class *ftype;
if( (ftype = FIELD_TYPE(&fld[lpc])) != NULL )
{
fmanglef(df->df_file,
".globl _ZN%q%d%sE\n",
df_quals, cl->name->data, cl->loader,
strlen(fld[lpc].name->data),
fld[lpc].name->data);
fmanglef(df->df_file,
"_ZN%q%d%sE = %p\n",
df_quals, cl->name->data, cl->loader,
strlen(fld[lpc].name->data),
fld[lpc].name->data,
FIELD_ADDRESS(&fld[lpc]));
fmanglef(df->df_file,
".stabs \"_ZN%q%d%sE:",
df_quals, cl->name->data, cl->loader,
strlen(fld[lpc].name->data),
fld[lpc].name->data);
fprintf(df->df_file,
"G%d\",%d,0,0,0\n",
ftype->stab_id,
N_GSYM);
}
}
fmanglef(df->df_file,
".globl _ZN%q%d%sE\n",
df_quals, cl->name->data, cl->loader,
strlen("class"),
"class");
fmanglef(df->df_file, "_ZN%q%d%sE = %p\n",
df_quals, cl->name->data, cl->loader,
strlen("class"),
"class",
cl);
fmanglef(df->df_file, ".stabs \"_ZN%q%d%sE:",
df_quals, cl->name->data, cl->loader,
strlen("class"),
"class");
fprintf(df->df_file,
"GxsHjava_lang_Class:\",%d,0,0,0\n",
N_GSYM);
}
/*
* Dynamically allocate space for a struct item plus the key and data
* elements. If name is non-NULL it is used as the key, else the
* uid is the key. Fills in datum from struct password.
*
* We would like to fill in the encrypted password too but the
* call to the shadow function could overwrite the pw buffer (NIS).
*/
static struct cache_item *
make_pwitem(const struct passwd *pw, const char *name)
{
char *cp;
const char *pw_shell;
size_t nsize, psize, csize, gsize, dsize, ssize, total;
struct cache_item *item;
struct passwd *newpw;
/* If shell field is empty, expand to _PATH_BSHELL. */
pw_shell = (pw->pw_shell == NULL || pw->pw_shell[0] == '\0')
? _PATH_BSHELL : pw->pw_shell;
/* Allocate in one big chunk for easy freeing. */
nsize = psize = csize = gsize = dsize = ssize = 0;
total = sizeof(struct cache_item) + sizeof(struct passwd);
FIELD_SIZE(pw, pw_name, nsize);
FIELD_SIZE(pw, pw_passwd, psize);
#ifdef HAVE_LOGIN_CAP_H
FIELD_SIZE(pw, pw_class, csize);
#endif
FIELD_SIZE(pw, pw_gecos, gsize);
FIELD_SIZE(pw, pw_dir, dsize);
/* Treat shell specially since we expand "" -> _PATH_BSHELL */
ssize = strlen(pw_shell) + 1;
total += ssize;
if (name != NULL)
total += strlen(name) + 1;
/* Allocate space for struct item, struct passwd and the strings. */
if ((item = malloc(total)) == NULL)
return NULL;
cp = (char *) item + sizeof(struct cache_item);
/*
* Copy in passwd contents and make strings relative to space
* at the end of the buffer.
*/
newpw = (struct passwd *) cp;
memcpy(newpw, pw, sizeof(struct passwd));
cp += sizeof(struct passwd);
FIELD_COPY(pw, newpw, pw_name, nsize);
FIELD_COPY(pw, newpw, pw_passwd, psize);
#ifdef HAVE_LOGIN_CAP_H
FIELD_COPY(pw, newpw, pw_class, csize);
#endif
FIELD_COPY(pw, newpw, pw_gecos, gsize);
FIELD_COPY(pw, newpw, pw_dir, dsize);
/* Treat shell specially since we expand "" -> _PATH_BSHELL */
memcpy(cp, pw_shell, ssize);
newpw->pw_shell = cp;
cp += ssize;
/* Set key and datum. */
if (name != NULL) {
memcpy(cp, name, strlen(name) + 1);
item->k.name = cp;
} else {
item->k.uid = pw->pw_uid;
}
item->d.pw = newpw;
item->refcnt = 1;
return item;
}
