addon.c

   1 #ifndef ADDON_C
   2 #define ADDON_C
   3
   4 #include "addon.h"
   5 #include "vg/vg_msg.h"
   6 #include "steam.h"
   7 #include "workshop_types.h"
   8 #include "workshop.h"
   9
  10 static u32 addon_count( enum workshop_file_type type ){
  11    return addon_system.registry_type_counts[ type ];
  12 }
  13
  14 /* these kind of suck, oh well. */
  15 static addon_reg *get_addon_from_index(enum workshop_file_type type, u32 index){
  16    u32 count = 0;
  17    for( u32 i=0; count<addon_count(type); i++ ){
  18       addon_reg *reg = &addon_system.registry[i];
  19       if( reg->type == type ){
  20          if( index == count )
  21             return reg;
  22
  23          count ++;
  24       }
  25    }
  26
  27    return NULL;
  28 }
  29
  30 static u32 get_index_from_addon( enum workshop_file_type type, addon_reg *a ){
  31    u32 count = 0;
  32    for( u32 i=0; count<addon_system.registry_type_counts[type]; i++ ){
  33       addon_reg *reg = &addon_system.registry[i];
  34       if( reg->type == type ){
  35          if( reg == a )
  36             return count;
  37
  38          count ++;
  39       }
  40    }
  41
  42    return 0xffffffff;
  43 }
  44
  45 static void addon_system_init( void ){
  46    u32 reg_size   = sizeof(addon_reg)*ADDON_MOUNTED_MAX;
  47    addon_system.registry = vg_linear_alloc( vg_mem.rtmemory, reg_size );
  48 }
  49
  50 /*
  51  * Scanning routines
  52  * -----------------------------------------------------------------------------
  53  */
  54
  55 /*
  56  * Reciever for scan completion. copies the registry counts back into main fred
  57  */
  58 VG_STATIC void async_addon_reg_update( void *data, u32 size )
  59 {
  60    vg_info( "Registry update notify\n" );
  61
  62    for( u32 i=0; i<k_workshop_file_type_max; i++ ){
  63       addon_system.registry_type_counts[i] = 0;
  64    }
  65
  66    for( u32 i=0; i<addon_system.registry_count; i++ ){
  67       addon_system.registry_type_counts[ addon_system.registry[i].type ] ++;
  68    }
  69 }
  70
  71 VG_STATIC void addon_set_foldername( addon_reg *reg, const char name[64] ){
  72    vg_strncpy( name, reg->foldername, 64, k_strncpy_always_add_null );
  73    reg->foldername_hash = vg_strdjb2( reg->foldername );
  74 }
  75
  76 /*
  77  * Create a new registry
  78  */
  79 VG_STATIC addon_reg *addon_alloc_reg( PublishedFileId_t workshop_id,
  80                                       enum workshop_file_type type ){
  81    if( addon_system.registry_count == ADDON_MOUNTED_MAX ){
  82       vg_error( "You have too many addons installed!\n" );
  83       return NULL;
  84    }
  85
  86    addon_reg *reg = &addon_system.registry[ addon_system.registry_count ];
  87    reg->metadata_len = 0;
  88    reg->userdata = NULL;
  89    reg->state = k_addon_state_indexed;
  90    reg->workshop_id = workshop_id;
  91    reg->foldername[0] = '\0';
  92    reg->type = type;
  93
  94    if( workshop_id ){
  95       char foldername[64];
  96       snprintf( foldername, 64, PRINTF_U64, workshop_id );
  97       addon_set_foldername( reg, foldername );
  98    }
  99    return reg;
 100 }
 101
 102 /*
 103  * If the addon.inf exists int the folder, load into the reg
 104  */
 105 VG_STATIC int addon_try_load_metadata( addon_reg *reg, vg_str folder_path ){
 106    vg_str meta_path = folder_path;
 107    vg_strcat( &meta_path, "/addon.inf" );
 108    if( !vg_strgood( &meta_path ) ){
 109       vg_error( "The metadata path is too long\n" );
 110       return 0;
 111    }
 112
 113    FILE *fp = fopen( meta_path.buffer, "rb" );
 114    if( !fp ){
 115       vg_error( "Could not open the '%s'\n", meta_path.buffer );
 116       return 0;
 117    }
 118
 119    reg->metadata_len = fread( reg->metadata, 1, 512, fp );
 120    if( reg->metadata_len != 512 ){
 121       if( !feof(fp) ){
 122          fclose(fp);
 123          vg_error( "unknown error codition" );
 124          reg->metadata_len = 0;
 125          return 0;
 126       }
 127    }
 128    fclose(fp);
 129    return 1;
 130 }
 131
 132 VG_STATIC void addon_print_info( addon_reg *reg ){
 133    vg_info( "addon_reg #%u{\n", addon_system.registry_count );
 134    vg_info( "  type: %d\n", reg->type );
 135    vg_info( "  workshop_id: " PRINTF_U64 "\n", reg->workshop_id );
 136    vg_info( "  folder: [%u]%s\n", reg->foldername_hash, reg->foldername );
 137    vg_info( "  metadata_len: %u\n", reg->metadata_len );
 138    vg_info( "  userdata: %p\n", reg->userdata );
 139    vg_info( "}\n" );
 140 }
 141
 142 VG_STATIC void addon_mount_finish( addon_reg *reg ){
 143    addon_system.registry_count ++;
 144 }
 145
 146 /*
 147  * Mount a fully packaged addon, one that certainly has a addon.inf
 148  */
 149 VG_STATIC addon_reg *addon_mount_workshop_folder( PublishedFileId_t workshop_id,
 150                                                   vg_str folder_path )
 151 {
 152    addon_reg *reg = addon_alloc_reg( workshop_id, k_workshop_file_type_none );
 153    if( !reg ) return NULL;
 154
 155    if( !addon_try_load_metadata( reg, folder_path ) ){
 156       return NULL;
 157    }
 158
 159    enum workshop_file_type type = k_workshop_file_type_none;
 160    vg_msg root;
 161    vg_msg_init( &root, reg->metadata, reg->metadata_len );
 162    vg_msg workshop = root;
 163    if( vg_msg_seekframe( &workshop, "workshop", k_vg_msg_first )){
 164       vg_msg_cmd kv_type = vg_msg_seekkv( &workshop, "type", k_vg_msg_first );
 165       if( kv_type.code & k_vg_msg_code_integer ){
 166          type = kv_type.value._u32;
 167       }
 168    }
 169
 170    if( type == k_workshop_file_type_none ){
 171       vg_error( "Cannot determine addon type\n" );
 172       return NULL;
 173    }
 174
 175    reg->type = type;
 176    addon_mount_finish( reg );
 177    return reg;
 178 }
 179
 180 /*
 181  * Mount a local folder. may or may not have addon.inf
 182  */
 183 VG_STATIC addon_reg *addon_mount_local_addon( const char *folder,
 184                                               enum workshop_file_type type,
 185                                               const char *content_ext )
 186 {
 187    char folder_path_buf[4096];
 188    vg_str folder_path;
 189    vg_strnull( &folder_path, folder_path_buf, 4096 );
 190    vg_strcat( &folder_path, folder );
 191
 192    const char *folder_name = vg_strch( &folder_path, '/' );
 193    u32 folder_hash = vg_strdjb2(folder_name);
 194    for( u32 i=0; i<addon_system.registry_count; i++ ){
 195       addon_reg *reg = &addon_system.registry[i];
 196
 197       if( (reg->type == type) && (reg->foldername_hash == folder_hash) ){
 198          if( !strcmp( reg->foldername, folder_name ) ){
 199             reg->state = k_addon_state_indexed;
 200             return NULL;
 201          }
 202       }
 203    }
 204
 205    addon_reg *reg = addon_alloc_reg( 0, type );
 206    if( !reg ) return NULL;
 207    addon_set_foldername( reg, folder_name );
 208    addon_try_load_metadata( reg, folder_path );
 209
 210    if( reg->metadata_len == 0 ){
 211       /* create our own content commands */
 212       vg_msg msg;
 213       vg_msg_init( &msg, reg->metadata, sizeof(reg->metadata) );
 214
 215       u32 content_count = 0;
 216
 217       vg_strcat( &folder_path, "" );
 218       vg_warn( "Creating own metadata for: %s\n", folder_path.buffer );
 219
 220       vg_dir subdir;
 221       if( !vg_dir_open(&subdir, folder_path.buffer) ){
 222          vg_error( "Failed to open '%s'\n", folder_path.buffer );
 223          return NULL;
 224       }
 225
 226       while( vg_dir_next_entry(&subdir) ){
 227          if( vg_dir_entry_type(&subdir) == k_vg_entry_type_file ){
 228             const char *fname = vg_dir_entry_name(&subdir);
 229             vg_str file = folder_path;
 230             vg_strcat( &file, "/" );
 231             vg_strcat( &file, fname );
 232             if( !vg_strgood( &file ) ) continue;
 233
 234             char *ext = vg_strch( &file, '.' );
 235             if( !ext ) continue;
 236             if( strcmp(ext,content_ext) ) continue;
 237
 238             vg_msg_wkvstr( &msg, "content", fname );
 239             content_count ++;
 240          }
 241       }
 242       vg_dir_close(&subdir);
 243
 244       if( !content_count ) return NULL;
 245       if( msg.error == k_vg_msg_error_OK )
 246          reg->metadata_len = msg.cur;
 247       else{
 248          vg_error( "Error creating metadata: %d\n", msg.error );
 249          return NULL;
 250       }
 251    }
 252
 253    addon_mount_finish( reg );
 254    return reg;
 255 }
 256
 257 /*
 258  * Check all subscribed items
 259  */
 260 VG_STATIC void addon_mount_workshop_items(void){
 261    if( !steam_ready ) return;
 262    /*
 263     * Steam workshop scan
 264     */
 265    vg_info( "Mounting steam workshop subscriptions\n" );
 266    PublishedFileId_t workshop_ids[ ADDON_MOUNTED_MAX ];
 267    u32 workshop_count = ADDON_MOUNTED_MAX;
 268
 269    vg_async_item *call = vg_async_alloc(
 270                            sizeof(struct async_workshop_installed_files_info));
 271    struct async_workshop_installed_files_info *info = call->payload;
 272    info->buffer = workshop_ids;
 273    info->len = &workshop_count;
 274    vg_async_dispatch( call, async_workshop_get_installed_files );
 275    vg_async_stall();
 276
 277    for( u32 j=0; j<workshop_count; j++ ){
 278       /* check for existance in both our caches
 279        * ----------------------------------------------------------*/
 280       PublishedFileId_t id = workshop_ids[j];
 281       for( u32 i=0; i<addon_system.registry_count; i++ ){
 282          addon_reg *reg = &addon_system.registry[i];
 283
 284          if( reg->workshop_id == id ){
 285             reg->state = k_addon_state_indexed;
 286             goto next_file_workshop;
 287          }
 288       }
 289
 290       vg_async_item *call1 =
 291          vg_async_alloc( sizeof(struct async_workshop_filepath_info) );
 292
 293       char path[ 4096 ];
 294
 295       struct async_workshop_filepath_info *info = call1->payload;
 296       info->buf = path;
 297       info->id = id;
 298       info->len = vg_list_size(path);
 299       vg_async_dispatch( call1, async_workshop_get_filepath );
 300       vg_async_stall(); /* too bad! */
 301
 302       vg_str folder = {.buffer = path, .i=strlen(path), .len=4096};
 303       addon_mount_workshop_folder( id, folder );
 304 next_file_workshop:;
 305    }
 306 }
 307
 308 /*
 309  * Scan a local content folder for addons. It must find at least one file with
 310  * the specified content_ext to be considered.
 311  */
 312 VG_STATIC void addon_mount_content_folder( enum workshop_file_type type,
 313                                            const char *base_folder,
 314                                            const char *content_ext )
 315 {
 316    vg_info( "Mounting addons(type:%d) matching skaterift/%s/*/*%s\n",
 317                   type, base_folder, content_ext );
 318
 319    char path_buf[4096];
 320    vg_str path;
 321    vg_strnull( &path, path_buf, 4096 );
 322    vg_strcat( &path, base_folder );
 323
 324    vg_dir dir;
 325    if( !vg_dir_open(&dir,path.buffer) ){
 326       vg_error( "vg_dir_open('%s') failed\n", path.buffer );
 327       vg_async_call( workshop_async_any_complete, NULL, 0 );
 328       return;
 329    }
 330
 331    vg_strcat(&path,"/");
 332
 333    while( vg_dir_next_entry(&dir) ){
 334       if( vg_dir_entry_type(&dir) == k_vg_entry_type_dir ){
 335          const char *d_name = vg_dir_entry_name(&dir);
 336
 337          vg_str folder = path;
 338          if( strlen( d_name ) > ADDON_FOLDERNAME_MAX ){
 339             vg_warn( "folder too long: %s\n", d_name );
 340             continue;
 341          }
 342
 343          vg_strcat( &folder, d_name );
 344          if( !vg_strgood( &folder ) ) continue;
 345
 346          addon_mount_local_addon( folder.buffer, type, content_ext );
 347       }
 348    }
 349    vg_dir_close(&dir);
 350 }
 351
 352 static int addon_get_content_folder( addon_reg *reg, vg_str *folder ){
 353    if( reg->workshop_id ){
 354       vg_async_item *call =
 355          vg_async_alloc( sizeof(struct async_workshop_filepath_info) );
 356       struct async_workshop_filepath_info *info = call->payload;
 357       info->buf = folder->buffer;
 358       info->id = reg->workshop_id;
 359       info->len = folder->len;
 360       vg_async_dispatch( call, async_workshop_get_filepath );
 361       vg_async_stall(); /* too bad! */
 362       if( info->buf[0] == '\0' ){
 363          vg_error( "Failed SteamAPI_GetItemInstallInfo(" PRINTF_U64 ")\n",
 364                      reg->workshop_id );
 365          return 0;
 366       }
 367       folder->i = strlen( folder->buffer );
 368       return 1;
 369    }
 370    else{
 371       folder->i = 0;
 372       if( reg->type == k_workshop_file_type_board )
 373          vg_strcat( folder, "boards/" );
 374       else if( reg->type == k_workshop_file_type_world )
 375          vg_strcat( folder, "maps/" );
 376       else return 0;
 377
 378       vg_strcat( folder, reg->foldername );
 379       return 1;
 380    }
 381 }
 382
 383 #endif /* ADDON_C */