/* 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; }