static const char *parse_master_line(PC_MASTER_ENT *masterp, const char *buf)
{
ARGV *argv;
/*
* We can't use the master daemon's master_ent routines in their current
* form. They convert everything to internal form, and they skip disabled
* services.
*
* The postconf command needs to show default fields as "-", and needs to
* know about all service names so that it can generate service-dependent
* parameter names (transport-dependent etc.).
*/
#define MASTER_BLANKS " \t\r\n" /* XXX */
argv = argv_split(buf, MASTER_BLANKS);
if (argv->argc < PC_MASTER_MIN_FIELDS) {
argv_free(argv);
return ("bad field count");
}
normalize_options(argv);
masterp->name_space =
concatenate(argv->argv[0], ".", argv->argv[1], (char *) 0);
masterp->argv = argv;
masterp->valid_names = 0;
masterp->all_params = 0;
return (0);
}
int git_clone(
git_repository **out,
const char *url,
const char *local_path,
const git_clone_options *options)
{
int retcode = GIT_ERROR;
git_repository *repo = NULL;
git_clone_options normOptions;
int remove_directory_on_failure = 0;
assert(out && url && local_path);
normalize_options(&normOptions, options);
GITERR_CHECK_VERSION(&normOptions, GIT_CLONE_OPTIONS_VERSION, "git_clone_options");
if (!path_is_okay(local_path)) {
return GIT_ERROR;
}
/* Only remove the directory on failure if we create it */
remove_directory_on_failure = !git_path_exists(local_path);
if (!(retcode = git_repository_init(&repo, local_path, normOptions.bare))) {
if ((retcode = setup_remotes_and_fetch(repo, url, &normOptions)) < 0) {
/* Failed to fetch; clean up */
git_repository_free(repo);
if (remove_directory_on_failure)
git_futils_rmdir_r(local_path, NULL, GIT_RMDIR_REMOVE_FILES);
else
git_futils_cleanupdir_r(local_path);
} else {
*out = repo;
retcode = 0;
}
}
if (!retcode && should_checkout(repo, normOptions.bare, &normOptions.checkout_opts))
retcode = git_checkout_head(*out, &normOptions.checkout_opts);
return retcode;
}
void read_master(int fail_on_open_error)
{
const char *myname = "read_master";
char *path;
VSTRING *buf;
ARGV *argv;
VSTREAM *fp;
int entry_count = 0;
int line_count = 0;
/*
* Sanity check.
*/
if (master_table != 0)
msg_panic("%s: master table is already initialized", myname);
/*
* Get the location of master.cf.
*/
if (var_config_dir == 0)
set_config_dir();
path = concatenate(var_config_dir, "/", MASTER_CONF_FILE, (char *) 0);
/*
* We can't use the master daemon's master_ent routines in their current
* form. They convert everything to internal form, and they skip disabled
* services.
*
* The postconf command needs to show default fields as "-", and needs to
* know about all service names so that it can generate service-dependent
* parameter names (transport-dependent etc.).
*/
#define MASTER_BLANKS " \t\r\n" /* XXX */
/*
* Initialize the in-memory master table.
*/
master_table = (PC_MASTER_ENT *) mymalloc(sizeof(*master_table));
/*
* Skip blank lines and comment lines. Degrade gracefully if master.cf is
* not available, and master.cf is not the primary target.
*/
if ((fp = vstream_fopen(path, O_RDONLY, 0)) == 0) {
if (fail_on_open_error)
msg_fatal("open %s: %m", path);
msg_warn("open %s: %m", path);
} else {
buf = vstring_alloc(100);
while (readlline(buf, fp, &line_count) != 0) {
master_table = (PC_MASTER_ENT *) myrealloc((char *) master_table,
(entry_count + 2) * sizeof(*master_table));
argv = argv_split(STR(buf), MASTER_BLANKS);
if (argv->argc < PC_MASTER_MIN_FIELDS)
msg_fatal("file %s: line %d: bad field count",
path, line_count);
normalize_options(argv);
master_table[entry_count].name_space =
concatenate(argv->argv[0], ".", argv->argv[1], (char *) 0);
master_table[entry_count].argv = argv;
master_table[entry_count].valid_names = 0;
master_table[entry_count].all_params = 0;
entry_count += 1;
}
vstream_fclose(fp);
vstring_free(buf);
}
/*
* Null-terminate the master table and clean up.
*/
master_table[entry_count].argv = 0;
myfree(path);
}
LIBCOUCHBASE_API
lcb_error_t lcb_create(lcb_t *instance,
const struct lcb_create_st *options)
{
const char *host = NULL;
const char *user = NULL;
const char *passwd = NULL;
const char *bucket = NULL;
struct lcb_io_opt_st *io = NULL;
struct lcb_create_st options_container;
struct lcb_create_st2 *e_options = &options_container.v.v2;
lcb_type_t type = LCB_TYPE_BUCKET;
lcb_t obj;
lcb_error_t err;
lcb_settings *settings;
err = normalize_options(&options_container, options);
if (err != LCB_SUCCESS) {
return err;
}
host = get_nonempty_string(e_options->host);
user = get_nonempty_string(e_options->user);
passwd = get_nonempty_string(e_options->passwd);
bucket = get_nonempty_string(e_options->bucket);
io = e_options->io;
type = e_options->type;
if (type == LCB_TYPE_CLUSTER && user == NULL && passwd == NULL) {
return LCB_EINVAL;
}
if (host == NULL) {
host = "localhost";
}
if (bucket == NULL) {
bucket = "default";
}
/* Do not allow people use Administrator account for data access */
if (type == LCB_TYPE_BUCKET && user && strcmp(user, bucket) != 0) {
return LCB_INVALID_USERNAME;
}
if ((obj = calloc(1, sizeof(*obj))) == NULL) {
return LCB_CLIENT_ENOMEM;
}
obj->type = type;
obj->compat.type = (lcb_compat_t)0xdead;
if (io == NULL) {
lcb_io_opt_t ops;
if ((err = lcb_create_io_ops(&ops, NULL)) != LCB_SUCCESS) {
/* You can't initialize the library without a io-handler! */
free(obj);
return err;
}
io = ops;
io->v.v0.need_cleanup = 1;
}
settings = &obj->settings;
settings->randomize_bootstrap_nodes = 1;
settings->bummer = 0;
settings->io = io;
obj->syncmode = LCB_ASYNCHRONOUS;
settings->ipv6 = LCB_IPV6_DISABLED;
settings->operation_timeout = LCB_DEFAULT_TIMEOUT;
settings->config_timeout = LCB_DEFAULT_CONFIGURATION_TIMEOUT;
settings->config_node_timeout = LCB_DEFAULT_NODECONFIG_TIMEOUT;
settings->views_timeout = LCB_DEFAULT_VIEW_TIMEOUT;
settings->rbufsize = LCB_DEFAULT_RBUFSIZE;
settings->wbufsize = LCB_DEFAULT_WBUFSIZE;
settings->durability_timeout = LCB_DEFAULT_DURABILITY_TIMEOUT;
settings->durability_interval = LCB_DEFAULT_DURABILITY_INTERVAL;
settings->http_timeout = LCB_DEFAULT_HTTP_TIMEOUT;
settings->weird_things_threshold = LCB_DEFAULT_CONFIG_ERRORS_THRESHOLD;
settings->weird_things_delay = LCB_DEFAULT_CONFIG_ERRORS_DELAY;
settings->max_redir = LCB_DEFAULT_CONFIG_MAXIMUM_REDIRECTS;
settings->grace_next_cycle = LCB_DEFAULT_CLCONFIG_GRACE_CYCLE;
settings->grace_next_provider = LCB_DEFAULT_CLCONFIG_GRACE_NEXT;
settings->bc_http_stream_time = LCB_DEFAULT_BC_HTTP_DISCONNTMO;
settings->bucket = strdup(bucket);
settings->logger = lcb_init_console_logger();
settings->iid = lcb_instance_index++;
if (user) {
settings->username = strdup(user);
} else {
settings->username = strdup(settings->bucket);
}
if (passwd) {
settings->password = strdup(passwd);
}
lcb_initialize_packet_handlers(obj);
obj->memd_sockpool = connmgr_create(settings, io);
obj->memd_sockpool->max_idle = 1;
obj->memd_sockpool->idle_timeout = 10000000;
obj->confmon = lcb_confmon_create(settings);
obj->usernodes = hostlist_create();
/** We might want to sanitize this a bit more later on.. */
if (strstr(host, "://") != NULL && strstr(host, "http://") == NULL) {
lcb_destroy(obj);
return LCB_INVALID_HOST_FORMAT;
}
err = hostlist_add_string(obj->usernodes, host, -1, LCB_CONFIG_HTTP_PORT);
if (err != LCB_SUCCESS) {
lcb_destroy(obj);
return err;
}
err = lcb_init_providers(obj, e_options);
if (err != LCB_SUCCESS) {
lcb_destroy(obj);
return err;
}
lcb_initialize_packet_handlers(obj);
obj->timers = hashset_create();
obj->http_requests = hashset_create();
obj->durability_polls = hashset_create();
/* No error has occurred yet. */
obj->last_error = LCB_SUCCESS;
if ((obj->cmdht = lcb_hashtable_szt_new(32)) == NULL) {
lcb_destroy(obj);
return LCB_CLIENT_ENOMEM;
}
if (!ringbuffer_initialize(&obj->purged_buf, 4096)) {
lcb_destroy(obj);
return LCB_CLIENT_ENOMEM;
}
if (!ringbuffer_initialize(&obj->purged_cookies, 4096)) {
lcb_destroy(obj);
return LCB_CLIENT_ENOMEM;
}
*instance = obj;
return LCB_SUCCESS;
}
int git_checkout_index(
git_repository *repo,
git_checkout_opts *opts,
git_indexer_stats *stats)
{
git_diff_list *diff = NULL;
git_indexer_stats dummy_stats;
git_diff_options diff_opts = {0};
git_checkout_opts checkout_opts;
struct checkout_diff_data data;
git_buf workdir = GIT_BUF_INIT;
int error;
assert(repo);
if ((error = git_repository__ensure_not_bare(repo, "checkout")) < 0)
return error;
diff_opts.flags =
GIT_DIFF_INCLUDE_UNTRACKED |
GIT_DIFF_INCLUDE_TYPECHANGE |
GIT_DIFF_SKIP_BINARY_CHECK;
if (opts && opts->paths.count > 0)
diff_opts.pathspec = opts->paths;
if ((error = git_diff_workdir_to_index(repo, &diff_opts, &diff)) < 0)
goto cleanup;
if ((error = git_buf_puts(&workdir, git_repository_workdir(repo))) < 0)
goto cleanup;
normalize_options(&checkout_opts, opts);
if (!stats)
stats = &dummy_stats;
stats->processed = 0;
/* total based on 3 passes, but it might be 2 if no submodules */
stats->total = (unsigned int)git_diff_num_deltas(diff) * 3;
memset(&data, 0, sizeof(data));
data.path = &workdir;
data.workdir_len = git_buf_len(&workdir);
data.checkout_opts = &checkout_opts;
data.stats = stats;
data.owner = repo;
if ((error = retrieve_symlink_capabilities(repo, &data.can_symlink)) < 0)
goto cleanup;
/* Checkout is best performed with three passes through the diff.
*
* 1. First do removes, because we iterate in alphabetical order, thus
* a new untracked directory will end up sorted *after* a blob that
* should be checked out with the same name.
* 2. Then checkout all blobs.
* 3. Then checkout all submodules in case a new .gitmodules blob was
* checked out during pass #2.
*/
if (!(error = git_diff_foreach(
diff, &data, checkout_remove_the_old, NULL, NULL)) &&
!(error = git_diff_foreach(
diff, &data, checkout_create_the_new, NULL, NULL)) &&
data.found_submodules)
{
data.create_submodules = true;
error = git_diff_foreach(
diff, &data, checkout_create_the_new, NULL, NULL);
}
stats->processed = stats->total;
cleanup:
if (error == GIT_EUSER)
error = (data.error != 0) ? data.error : -1;
git_diff_list_free(diff);
git_buf_free(&workdir);
return error;
}