The nacl_io Library

nacl_io_demo.c

This is the demo’s main file. The code here creates and initializes the Native Client module instance. The Pepper function Instance_DidCreate initializes nacl_io and mounts an HTML5 filesystem at /persistent.

static PP_Bool Instance_DidCreate(PP_Instance instance,
                                  uint32_t argc,
                                  const char* argn[],
                                  const char* argv[]) {
  g_instance = instance;
  nacl_io_init_ppapi(instance, get_browser_interface);
  mount(
      "",  /* source */
      "/persistent",  /* target */
      "html5fs",  /* filesystemtype */
      0,  /* mountflags */
      "type=PERSISTENT,expected_size=1048576");  /* data specific to the html5fs type */

  pthread_create(&g_handle_message_thread, NULL, &HandleMessageThread, NULL);
  InitializeMessageQueue();

  return PP_TRUE;
}

Space is allocated to the /persistent file system after the module is initialized. This is accomplished by the domContentLoaded function in the file example.js. This script is included in the module’s html page (see examples/demo/index.html):

function domContentLoaded(name, tc, config, width, height) {
  navigator.webkitPersistentStorage.requestQuota(window.PERSISTENT, 1024 * 1024,
      function(bytes) {
        common.updateStatus(
            'Allocated ' + bytes + ' bytes of persistant storage.');
        common.createNaClModule(name, tc, config, width, height);
        common.attachDefaultListeners();
      },
      function(e) { alert('Failed to allocate space') });
}

The Instance_DidCreate function also creates a worker thread that receives messages sent from the html page and performs the specified file system operations. The logic for the worker thread is encoded in the other two files, described below.

queue.c

This file implements a circular queue that is used to receive messages from the browser UI to the Native Client module. The file system commands in the enqueued messages are executed on the worker thread. This keeps blocking calls (like fread) off the main Native Client thread, which is a good thing. The queue is initialized in nacl_io_demo.c Instance_DidCreate.

handlers.c

This file implements the stdio calls associated with the commands sent from the browser. There is a separate Handle* function for each command: fopen, fclose, fseek, fread, fwrite. The handlers are called from the HandleMessage function in nacl_io_demo.c, which runs in the worker thread managing the message queue. The code for the fwrite handler appears below. Notice that it does not contain any PPAPI calls and looks like “ordinary” C code.

int HandleFwrite(int num_params, char** params, char** output) {
  FILE* file;
  const char* file_index_string;
  const char* data;
  size_t data_len;
  size_t bytes_written;

  if (num_params != 2) {
    *output = PrintfToNewString("Error: fwrite takes 2 parameters.");
    return 1;
  }

  file_index_string = params[0];
  file = GetFileFromIndexString(file_index_string, NULL);
  data = params[1];
  data_len = strlen(data);

  if (!file) {
    *output = PrintfToNewString("Error: Unknown file handle %s.",
                                file_index_string);
    return 2;
  }

  bytes_written = fwrite(data, 1, data_len, file);

  *output = PrintfToNewString("fwrite\1%s\1%d", file_index_string,
                              bytes_written);
  return 0;
}