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