/* ast_type_isa:
*/
gboolean ast_type_isa ( ASTType type1,
ASTType type2 )
{
TypeNode *n1 = type_lookup(type1);
TypeNode *n2 = type_lookup(type2);
while (n1)
{
if (n1 == n2)
return TRUE;
n1 = n1->parent;
}
return FALSE;
}
/* Does the parent pointer propogate down? */
int type_is_sticky(xn_elem_t type) {
struct udf_type *t;
t = type_lookup(type);
demand(t, impossible);
return t->is_sticky;
}
xn_err_t type_readable(xn_elem_t type, cap_t cap, size_t toff, size_t nbytes) {
struct udf_type *t;
ensure(t = type_lookup(type), XN_BOGUS_TYPE);
/* Allowed if [toff, toff+nbytes) is entirely within the raw set */
return !u_in_set(&t->u.t.raw_read, toff, nbytes) ?
XN_BOGUS_CAP : XN_SUCCESS;
}
void add_type(char* name){
if(types == NULL)
types = mklist();
if(type_lookup(name) != UNDEFINED_TYPE)
error("Redefinition of type '%s'", name);
type_container* t = MKNEW(type_container);
t->name = name;
t->methods = mklist();
t->traits = mklist();
append(types, (void*) t);
}
/* type_register:
*/
static void type_register ( TypeInfo *info )
{
TypeNode *node;
ASSERT(info->type > 0);
ASSERT(info->name);
node = g_new0(TypeNode, 1);
node->type = info->type;
node->name = g_strdup(info->name);
if (info->parent == 0) {
node->parent = NULL;
} else {
node->parent = type_lookup(info->parent);
}
if (info->type >= type_nodes->len)
g_ptr_array_set_size(type_nodes, info->type+1);
ASSERT(!type_nodes->pdata[info->type]);
type_nodes->pdata[node->type] = node;
}
DDS_ReturnCode_t DDS_DomainParticipant_unregister_type (DDS_DomainParticipant dp,
DDS_TypeSupport ts,
const char *type_name)
{
TopicType_t *typep;
struct type_lookup_st lookup;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DP_U_TYPE, &dp, sizeof (dp));
ctrc_contd (&ts, sizeof (ts));
ctrc_contd (type_name, strlen (type_name));
ctrc_endd ();
prof_start (dcps_unreg_type);
/* Validate some required arguments. */
if (!ts)
return (DDS_RETCODE_BAD_PARAMETER);
if (!domain_ptr (dp, 1, &ret))
return (ret);
/* Search type name in participant type list. */
typep = type_lookup (dp, type_name);
if (!typep ||
#if !defined DDS_TYPECODE
typep->type_support != ts ||
#endif
(typep->flags & EF_LOCAL) == 0) {
lock_release (dp->lock);
return (DDS_RETCODE_ALREADY_DELETED);
}
/* Type exists and is locally created.
Check if there are local topics that are still using the type. */
lookup.type = typep;
lookup.nusers = 0;
sl_walk (&dp->participant.p_topics, topic_type_check_fct, &lookup);
if (lookup.nusers) {
if (typep->nrefs > lookup.nusers + 1) {
ret = DDS_RETCODE_OK;
typep->nrefs--;
if (--typep->nlrefs == 0) {
typep->flags &= ~EF_LOCAL;
DDS_TypeSupport_delete(typep->type_support);
}
}
else
ret = DDS_RETCODE_PRECONDITION_NOT_MET;
lock_release (dp->lock); /* Still in use! */
return (ret);
}
if (--typep->nlrefs == 0) {
typep->flags &= ~EF_LOCAL;
DDS_TypeSupport_delete(typep->type_support);
typep->type_support = NULL;
}
type_delete (dp, typep);
lock_release (dp->lock);
prof_stop (dcps_unreg_type, 1);
return (DDS_RETCODE_OK);
}
DDS_ReturnCode_t DDS_DomainParticipant_register_type (DDS_DomainParticipant dp,
DDS_TypeSupport ts,
const char *type_name)
{
TopicType_t *typep;
TypeSupport_t *pts;
DDS_ReturnCode_t ret;
#ifdef DDS_TYPECODE
unsigned char *vtc;
#endif
ctrc_begind (DCPS_ID, DCPS_DP_R_TYPE, &dp, sizeof (dp));
ctrc_contd (&ts, sizeof (ts));
ctrc_contd (type_name, strlen (type_name));
ctrc_endd ();
prof_start (dcps_reg_type);
/* Validate some required arguments. */
if (!ts)
return (DDS_RETCODE_BAD_PARAMETER);
if (!domain_ptr (dp, 1, &ret))
return (ret);
if (!type_name &&
(type_name = DDS_TypeSupport_get_type_name (ts)) == NULL)
return (DDS_RETCODE_BAD_PARAMETER);
/* Search type name in participant type list. */
typep = type_lookup (dp, type_name);
if (typep) {
if ((pts = typep->type_support) != NULL) {
#ifdef DDS_TYPECODE
/* Type already learned from remote peers? */
if (pts->ts_prefer >= MODE_V_TC) {
vtc = (unsigned char *) pts->ts_vtc;
if (!vtc_identical (ts, vtc)) {
/* Oops: already present in domain but
incompatible - notify later when
a topic is created. */
typep->flags |= EF_INC_TYPE;
type_promote_tc (dp, typep, ts, NULL);
}
else {
typep->flags &= ~EF_INC_TYPE;
type_promote_tc (dp, typep, ts, vtc);
}
/* Replace with real type support.*/
xfree (typep->type_support);
typep->type_support = (TypeSupport_t *) ts;
vtc_free (vtc);
}
else
/* Already defined: check compatibility. */
if (ts->ts_prefer != pts->ts_prefer ||
ts->ts_keys != pts->ts_keys ||
ts->ts_fksize != pts->ts_fksize ||
ts->ts_length != pts->ts_length ||
ts->ts_mkeysize != pts->ts_mkeysize)
return (DDS_RETCODE_PRECONDITION_NOT_MET);
else if (ts->ts_prefer == MODE_CDR) {
if (!xt_type_equal (ts->ts_cdr, pts->ts_cdr))
return (DDS_RETCODE_PRECONDITION_NOT_MET);
}
else if (ts->ts_prefer == MODE_PL_CDR) {
if (pts->ts_pl->builtin ||
ts->ts_pl->builtin ||
!xt_type_equal (ts->ts_pl->xtype, pts->ts_pl->xtype))
return (DDS_RETCODE_PRECONDITION_NOT_MET);
}
else
#else
if (pts != ts)
#endif
return (DDS_RETCODE_PRECONDITION_NOT_MET);
}
else {
typep->type_support = (TypeSupport_t *) ts;
typep->type_support->ts_users++;
}
}
else {
/* Doesn't exist yet -- allocate new type context. */
typep = type_create (dp, type_name, NULL);
if (!typep) {
warn_printf ("create_topic_type (%s): out of memory for topic type!\r\n", type_name);
lock_release (dp->lock);
return (DDS_RETCODE_OUT_OF_RESOURCES);
}
typep->type_support = (TypeSupport_t *) ts;
typep->type_support->ts_users++;
}
typep->flags |= EF_LOCAL;
typep->nrefs++;
typep->nlrefs++;
lock_release (dp->lock);
prof_stop (dcps_reg_type, 1);
return (DDS_RETCODE_OK);
}
/* ast_type_name:
*/
const gchar *ast_type_name ( ASTType type )
{
TypeNode *n = type_lookup(type);
return n->name;
}
/* ast_type_parent:
*/
ASTType ast_type_parent ( ASTType type )
{
TypeNode *n = type_lookup(type);
return n->parent ? n->parent->type : 0;
}
int msg_start (Domain_t *dp)
{
Reader_t *rp;
TopicType_t *tp;
int error;
error = DDS_DomainParticipant_register_type ((DDS_DomainParticipant) dp,
dds_participant_msg_ts,
"ParticipantMessageData");
if (error) {
warn_printf ("disc_start: can't register ParticipantMessageData type!");
return (error);
}
if (lock_take (dp->lock)) {
warn_printf ("disc_start: domain lock error (2)");
return (DDS_RETCODE_ERROR);
}
tp = type_lookup (dp, "ParticipantMessageData");
if (tp)
tp->flags |= EF_BUILTIN;
lock_release (dp->lock);
/* Create builtin Participant Message Reader. */
error = create_builtin_endpoint (dp, EPB_PARTICIPANT_MSG_R,
0, 1,
1, 0, 1,
NULL,
dp->participant.p_meta_ucast,
dp->participant.p_meta_mcast,
NULL);
if (error)
return (error);
/* Attach to builtin Participant Message Reader. */
rp = (Reader_t *) dp->participant.p_builtin_ep [EPB_PARTICIPANT_MSG_R];
error = hc_request_notification (rp->r_cache, disc_data_available, (uintptr_t) rp);
if (error) {
fatal_printf ("msg_start: can't register Message Reader!");
return (error);
}
/* Create builtin Participant Message Writer. */
error = create_builtin_endpoint (dp, EPB_PARTICIPANT_MSG_W,
1, 1,
1, 0, 1,
NULL,
dp->participant.p_meta_ucast,
dp->participant.p_meta_mcast,
NULL);
if (error)
return (error);
#if defined (DDS_SECURITY) && defined (DDS_NATIVE_SECURITY)
if (NATIVE_SECURITY (dp)) {
/* Create builtin Participant Secure Message Reader. */
error = create_builtin_endpoint (dp, EPB_PARTICIPANT_MSG_SEC_R,
0, 1,
1, 0, 1,
NULL,
dp->participant.p_meta_ucast,
dp->participant.p_meta_mcast,
NULL);
if (error)
return (error);
/* Attach to builtin Participant Secure Message Reader. */
rp = (Reader_t *) dp->participant.p_builtin_ep [EPB_PARTICIPANT_MSG_SEC_R];
error = hc_request_notification (rp->r_cache, disc_data_available, (uintptr_t) rp);
if (error) {
fatal_printf ("msg_start: can't register secure Message Reader!");
return (error);
}
/* Create builtin Participant Secure Message Writer. */
error = create_builtin_endpoint (dp, EPB_PARTICIPANT_MSG_SEC_W,
1, 1,
1, 0, 1,
NULL,
dp->participant.p_meta_ucast,
dp->participant.p_meta_mcast,
NULL);
if (error)
return (error);
}
#endif
return (DDS_RETCODE_OK);
}
int main(int argc, char* argv[]) {
int opt;
char* outdir = NULL;
bool orphaned_check = false, recreate = false, quiet = false;
while((opt = getopt(argc,argv,"roqd:hD")) != -1)
switch(opt) {
case 'o': orphaned_check = true; break;
case 'r': recreate = true; break;
case 'd': outdir = optarg; break;
case 'q': quiet = true; break;
case 'D': puts(doc); return 0;
case 'h': usage(argv[0],1);
default : usage(argv[0],0);
}
if(argc - optind != 1)
usage(argv[0],0);
if(recreate && !outdir)
outdir = ".";
const char* browsefile = argv[optind];
FILE* f = fopen(browsefile,"rb");
if(!f)
bail("%s could not be read.\n",browsefile);
char buf[15];
CHECKREAD(buf,1,15,f);
if(memcmp(buf,magic,15))
bail("%s: Not a valid JBF.\n",browsefile);
uint16_t version[2];
READBE(version,2,2,f);
uint32_t nb_images;
READLE(&nb_images,4,1,f);
char path[256];
CHECKREAD(path,1,256,f);
path[255] = '\0';
char volume[32];
CHECKREAD(volume,1,32,f);
volume[31] = '\0';
fseek(f,713,SEEK_CUR); // End header
if(!quiet) {
printf("JBF version %d.%d (PSP %s)\n",version[0],version[1],ver_lookup(version[0],version[1]));
if(volume[0]) printf("[%s] ",volume);
printf("%s\n%d images\n",path,nb_images);
puts(" type resolution bpp size modified name");
}
size_t outdir_len;
if(outdir)
outdir_len = strlen(outdir);
if(recreate) {
outdir_len += strlen(path);
outdir = strcpy(malloc(outdir_len+1),outdir);
char* pp = path,* op = outdir + strlen(outdir);
*op++ = '/';
do switch(*pp) {
case '\\': *op++ = '/'; break;
case '/' : *op++ = '\\'; break;
case ':' : break;
default : *op++ = *pp;
} while(*pp++);
}
char* browsedir;
size_t browsedir_len;
if(orphaned_check) {
char* browsecpy = strdup(browsefile);
browsedir = strdup(dirname(browsecpy));
browsedir_len = strlen(browsedir);
free(browsecpy);
}
for(uint32_t i = 0; i < nb_images; i++) {
uint32_t name_len;
if(version[0] == 1 && version[1] == 0)
name_len = 13;
else
READLE(&name_len,4,1,f);
if(name_len > 255) //Windows maximum, image names from valid JBFs shouldn't exceed this
bail("%s+%lx: Filename too long for image #%"PRIu32" (%"PRIu32")\n",browsefile,ftell(f)-4,i,name_len);
char name[256];
READLE(name,1,name_len,f);
name[name_len] = '\0';
if(version[0] == 1 && version[1] == 0)
name_len--;
uint32_t type, width, height, depth, pels, filesize;
time_t epochtime;
char type_v1[4] = {'\0'};
if(version[0] > 1) {
uint64_t filetime;
READLE(&filetime,8,1,f);
epochtime = MSFILETIME_TO_EPOCHTIME(filetime);
READLE(&type,4,1,f);
}
else if(version[1] < 3) { //1.3 has no type code
READBE(type_v1,3,1,f);
CHECKREAD(type_v1+3,1,1,f); // \0
}
READLE(&width,4,1,f);
READLE(&height,4,1,f);
READLE(&depth,4,1,f);
if(version[0] == 2)
READLE(&pels,4,1,f); // Still not sure what this field is for, roughly equals w*h*channels
READLE(&filesize,4,1,f);
if(version[0] == 1) {
uint32_t filetime;
READLE(&filetime,4,1,f);
epochtime = filetime;
}
// Truncated file entries contain a single null word in place of the '0x00000002 0x00000001 0xFFFFFFFF' pattern
uint32_t has_thumb = true;
if(version[0] == 2)
READLE(&has_thumb,4,1,f);
bool orphaned = false;
if(orphaned_check) {
char test[browsedir_len+name_len+2];
sprintf(test,"%s/%s",browsedir,name);
orphaned = access(test,F_OK);
}
bool extract = outdir && (!orphaned_check || orphaned);
if(!quiet)
printf("%c%6s %6"PRIu32"x%-6"PRIu32" %2"PRIu32" %10"PRIu32" %.20s %s %s %s\n",
(has_thumb?' ':'-'),version[0]<2?type_v1:type_lookup(type),width,height,depth,filesize,ctime(&epochtime)+4,(orphaned?"\033[1;31m":""),name,(orphaned?"\033[0m":""));
if(!has_thumb)
continue;
if(extract && recreate) {
if(!mkdir_r(outdir))
bail("%s: Couldn't recreate path: %s\n%s\n",browsefile,outdir,strerror(errno));
#if !defined(_WIN32) || (WINVER >= 0x0600) // place a symlink back to the source jbf
char* browsecpy = strdup(browsefile);
char* browsebase = basename(browsecpy);
free(browsecpy);
char linkback[outdir_len+strlen(browsebase)+1];
strcat(strcpy(linkback,outdir),browsebase);
char* browseabs = realpath(browsefile,NULL);
symlink(browseabs,linkback);
free(browseabs);
#endif
recreate = false;
}
if(version[0] == 2) {
uint32_t sig[3] = {has_thumb};
READLE(sig+1,4,2,f);
if(memcmp(sig,v2_thumb_signature,sizeof(v2_thumb_signature)))
bail("%s+%lx: Wrong signature (%08"PRIX32" %08"PRIX32" %08"PRIX32"); parse integrity lost.\n",browsefile,ftell(f)-3,sig[0],sig[1],sig[2]);
uint32_t imglen;
READLE(&imglen,4,1,f);
if(extract) {
char writepath[outdir_len+name_len+6];
sprintf(writepath,"%s/%s.jpg",outdir,name);
FILE* thumb = fopen(writepath,"wb");
if(thumb) {
char* buf = malloc(imglen);
if(!buf)
bail("%s+%lx: Allocation failed for image #%"PRIu32", length %"PRIu32"\n",browsefile,ftell(f)-4,i,imglen);
imglen = fread(buf,1,imglen,f); // If the file is truncated for any reason we will write a partial JPEG and fail the next time around
if(fwrite(buf,1,imglen,thumb) != imglen)
fprintf(stderr,"Error writing to %s\n",writepath);
fclose(thumb);
free(buf);
utime(writepath,&(struct utimbuf){epochtime,epochtime});
continue;
}
fprintf(stderr,"Unable to open %s\n",writepath);
}
fseek(f,imglen,SEEK_CUR);
}
xn_err_t type_size(xn_elem_t type) {
struct udf_type *t;
ensure(t = type_lookup(type), XN_BOGUS_TYPE);
return t->nbytes;
}
