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