int
test_curve(void)
{
spiro_cp path[] = {
{334, 117, 'v'},
{305, 176, 'v'},
{212, 142, 'c'},
{159, 171, 'c'},
{224, 237, 'c'},
{347, 335, 'c'},
{202, 467, 'c'},
{81, 429, 'v'},
{114, 368, 'v'},
{201, 402, 'c'},
{276, 369, 'c'},
{218, 308, 'c'},
{91, 211, 'c'},
{124, 111, 'c'},
{229, 82, 'c'}
};
spiro_seg *segs;
int i;
n = 1;
for (i = 0; i < 1000; i++) {
segs = setup_path(path, 15);
solve_spiro(segs, 15);
}
printf("100 800 translate 1 -1 scale 1 setlinewidth\n");
print_segs(segs, 15);
printf("showpage\n");
return 0;
}
static void
make_path( sliceable_switch *sliceable_switch, uint64_t in_datapath_id, uint16_t in_port, uint16_t in_vid,
uint64_t out_datapath_id, uint16_t out_port, uint16_t out_vid, const buffer *packet ) {
dlist_element *hops = resolve_path( sliceable_switch->pathresolver, in_datapath_id, in_port, out_datapath_id, out_port );
if ( hops == NULL ) {
warn( "No available path found ( %#" PRIx64 ":%u -> %#" PRIx64 ":%u ).",
in_datapath_id, in_port, out_datapath_id, out_port );
discard_packet_in( in_datapath_id, in_port, packet );
return;
}
// check if the packet is ARP or not
if ( sliceable_switch->handle_arp_with_packetout && packet_type_arp( packet ) ) {
// send packet out for tail switch
free_hop_list( hops );
output_packet( packet, out_datapath_id, out_port, out_vid );
return;
}
const uint32_t wildcards = 0;
struct ofp_match match;
set_match_from_packet( &match, in_port, wildcards, packet );
if ( lookup_path( in_datapath_id, match, PRIORITY ) != NULL ) {
warn( "Duplicated path found." );
output_packet( packet, out_datapath_id, out_port, out_vid );
return;
}
const uint16_t hard_timeout = 0;
path *p = create_path( match, PRIORITY, sliceable_switch->idle_timeout, hard_timeout );
assert( p != NULL );
for ( dlist_element *e = get_first_element( hops ); e != NULL; e = e->next ) {
pathresolver_hop *rh = e->data;
hop *h = create_hop( rh->dpid, rh->in_port_no, rh->out_port_no, NULL );
assert( h != NULL );
append_hop_to_path( p, h );
} // for(;;)
dlist_element *e = get_last_element( hops );
pathresolver_hop *last_hop = e->data;
packet_out_params *params = xmalloc( sizeof( struct packet_out_params ) );
params->packet = duplicate_buffer( packet );
params->out_datapath_id = last_hop->dpid;
params->out_port_no = last_hop->out_port_no;
params->out_vid = out_vid;
bool ret = setup_path( p, handle_setup, params, NULL, NULL );
if ( ret != true ) {
error( "Failed to set up path." );
output_packet( packet, out_datapath_id, out_port, out_vid );
free_buffer( params->packet );
xfree( params );
}
delete_path( p );
// free them
free_hop_list( hops );
}
int cmd_receive_pack(int argc, const char **argv, const char *prefix)
{
int i;
char *dir = NULL;
argv++;
for (i = 1; i < argc; i++) {
const char *arg = *argv++;
if (*arg == '-') {
/* Do flag handling here */
usage(receive_pack_usage);
}
if (dir)
usage(receive_pack_usage);
dir = xstrdup(arg);
}
if (!dir)
usage(receive_pack_usage);
setup_path();
if (!enter_repo(dir, 0))
die("'%s': unable to chdir or not a git archive", dir);
if (is_repository_shallow())
die("attempt to push into a shallow repository");
git_config(receive_pack_config, NULL);
if (0 <= transfer_unpack_limit)
unpack_limit = transfer_unpack_limit;
else if (0 <= receive_unpack_limit)
unpack_limit = receive_unpack_limit;
add_alternate_refs();
write_head_info();
clear_extra_refs();
/* EOF */
packet_flush(1);
read_head_info();
if (commands) {
const char *unpack_status = NULL;
if (!delete_only(commands))
unpack_status = unpack();
execute_commands(unpack_status);
if (pack_lockfile)
unlink(pack_lockfile);
if (report_status)
report(unpack_status);
run_receive_hook(post_receive_hook);
run_update_post_hook(commands);
}
return 0;
}
int cmd_main(int argc, const char **argv)
{
char *method = getenv("REQUEST_METHOD");
char *dir;
struct service_cmd *cmd = NULL;
char *cmd_arg = NULL;
int i;
struct strbuf hdr = STRBUF_INIT;
set_die_routine(die_webcgi);
set_die_is_recursing_routine(die_webcgi_recursing);
if (!method)
die("No REQUEST_METHOD from server");
if (!strcmp(method, "HEAD"))
method = "GET";
dir = getdir();
for (i = 0; i < ARRAY_SIZE(services); i++) {
struct service_cmd *c = &services[i];
regex_t re;
regmatch_t out[1];
if (regcomp(&re, c->pattern, REG_EXTENDED))
die("Bogus regex in service table: %s", c->pattern);
if (!regexec(&re, dir, 1, out, 0)) {
size_t n;
if (strcmp(method, c->method))
return bad_request(&hdr, c);
cmd = c;
n = out[0].rm_eo - out[0].rm_so;
cmd_arg = xmemdupz(dir + out[0].rm_so + 1, n - 1);
dir[out[0].rm_so] = 0;
break;
}
regfree(&re);
}
if (!cmd)
not_found(&hdr, "Request not supported: '%s'", dir);
setup_path();
if (!enter_repo(dir, 0))
not_found(&hdr, "Not a git repository: '%s'", dir);
git_config(git_default_config, NULL);
if (!getenv("GIT_HTTP_EXPORT_ALL") &&
access("git-daemon-export-ok", F_OK) )
not_found(&hdr, "Repository not exported: '%s'", dir);
http_config();
max_request_buffer = git_env_ulong("GIT_HTTP_MAX_REQUEST_BUFFER",
max_request_buffer);
cmd->imp(&hdr, cmd_arg);
return 0;
}
spiro_seg *
run_spiro(const spiro_cp *src, int n)
{
int nseg = src[0].ty == '{' ? n - 1 : n;
spiro_seg *s = setup_path(src, n);
if (nseg > 1)
solve_spiro(s, nseg);
return s;
}
int cmd_main(int argc, const char **argv)
{
const char *dir;
int strict = 0;
struct option options[] = {
OPT_BOOL(0, "stateless-rpc", &stateless_rpc,
N_("quit after a single request/response exchange")),
OPT_BOOL(0, "advertise-refs", &advertise_refs,
N_("exit immediately after initial ref advertisement")),
OPT_BOOL(0, "strict", &strict,
N_("do not try <directory>/.git/ if <directory> is no Git directory")),
OPT_INTEGER(0, "timeout", &timeout,
N_("interrupt transfer after <n> seconds of inactivity")),
OPT_END()
};
packet_trace_identity("upload-pack");
check_replace_refs = 0;
argc = parse_options(argc, argv, NULL, options, upload_pack_usage, 0);
if (argc != 1)
usage_with_options(upload_pack_usage, options);
if (timeout)
daemon_mode = 1;
setup_path();
dir = argv[0];
if (!enter_repo(dir, strict))
die("'%s' does not appear to be a git repository", dir);
git_config(upload_pack_config, NULL);
switch (determine_protocol_version_server()) {
case protocol_v1:
/*
* v1 is just the original protocol with a version string,
* so just fall through after writing the version string.
*/
if (advertise_refs || !stateless_rpc)
packet_write_fmt(1, "version 1\n");
/* fallthrough */
case protocol_v0:
upload_pack();
break;
case protocol_unknown_version:
BUG("unknown protocol version");
}
return 0;
}
int main(int argc, char **argv)
{
char *dir;
int i;
int strict = 0;
git_setup_gettext();
packet_trace_identity("upload-pack");
git_extract_argv0_path(argv[0]);
read_replace_refs = 0;
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (arg[0] != '-')
break;
if (!strcmp(arg, "--advertise-refs")) {
advertise_refs = 1;
continue;
}
if (!strcmp(arg, "--stateless-rpc")) {
stateless_rpc = 1;
continue;
}
if (!strcmp(arg, "--strict")) {
strict = 1;
continue;
}
if (!prefixcmp(arg, "--timeout=")) {
timeout = atoi(arg+10);
daemon_mode = 1;
continue;
}
if (!strcmp(arg, "--")) {
i++;
break;
}
}
if (i != argc-1)
usage(upload_pack_usage);
setup_path();
dir = argv[i];
if (!enter_repo(dir, strict))
die("'%s' does not appear to be a git repository", dir);
if (is_repository_shallow())
die("attempt to fetch/clone from a shallow repository");
git_config(upload_pack_config, NULL);
upload_pack();
return 0;
}
static int do_cvs_cmd(const char *me, char *arg)
{
const char *cvsserver_argv[3] = {
"cvsserver", "server", NULL
};
if (!arg || strcmp(arg, "server"))
die("git-cvsserver only handles server: %s", arg);
setup_path();
return execv_git_cmd(cvsserver_argv);
}
static void
gedit_app_win32_startup (GApplication *application)
{
G_APPLICATION_CLASS (gedit_app_win32_parent_class)->startup (application);
setup_path ();
prep_console ();
/* manually set name and icon */
g_set_application_name("gedit");
gtk_window_set_default_icon_name ("accessories-text-editor");
}
static void
setup_reverse_path( int status, const path *p, void *user_data ) {
assert(user_data);
packet_out_params *params = user_data;
if ( status != SETUP_SUCCEEDED ) {
error( "Failed to set up path ( status = %d ).", status );
output_packet( params->packet, params->out_datapath_id, params->out_port_no, params->out_vid );
free_buffer( params->packet );
xfree( params );
return;
}
struct ofp_match rmatch;
set_ipv4_reverse_match( &rmatch, &(p->match) );
rmatch.dl_vlan = params->out_vid;
openflow_actions *vlan_actions;
vlan_actions = create_openflow_actions_to_update_vid( params->out_vid, params->in_vid );
path *rpath = create_path( rmatch, p->priority, p->idle_timeout, p->hard_timeout );
assert( rpath != NULL );
list_element *hops = p->hops;
dlist_element *rhops = create_dlist();
while ( hops != NULL ) {
hop *h = hops->data;
assert( h != NULL );
hop *rh = create_hop( h->datapath_id, h->out_port, h->in_port, vlan_actions );
if ( vlan_actions ) {
delete_actions( vlan_actions );
vlan_actions = NULL;
}
assert( rh != NULL );
rhops = insert_before_dlist( rhops, rh );
hops = hops->next;
}
while ( rhops != NULL && rhops->data != NULL ) {
append_hop_to_path( rpath, ( hop * ) rhops->data );
rhops = rhops->next;
}
bool ret = setup_path( rpath, handle_setup, params, NULL, NULL );
if ( ret != true ) {
error( "Failed to set up reverse path." );
output_packet( params->packet, params->out_datapath_id, params->out_port_no, params->out_vid );
free_buffer( params->packet );
xfree( params );
}
delete_path( rpath );
delete_dlist( rhops );
}
spiro_seg *
run_spiro(const spiro_cp *src, int n)
{
if (src==NULL || n <= 0) return 0;
int nseg = src[0].ty == '{' ? n - 1 : n;
spiro_seg *s = setup_path(src, n);
if (s) {
int converged = 1 ; // this value is for when nseg == 1; else actual value determined below
if (nseg > 1) converged = solve_spiro(s, nseg);
if (converged) return s;
free(s);
}
return 0;
}
static int do_generic_cmd(const char *me, char *arg)
{
const char *my_argv[4];
setup_path();
if (!arg || !(arg = sq_dequote(arg)))
die("bad argument");
if (prefixcmp(me, "git-"))
die("bad command");
my_argv[0] = me + 4;
my_argv[1] = arg;
my_argv[2] = NULL;
return execv_git_cmd(my_argv);
}
int main(int argc, char **argv)
{
char *dir;
int i;
int strict = 0;
git_extract_argv0_path(argv[0]);
read_replace_refs = 0;
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (arg[0] != '-')
break;
if (!strcmp(arg, "--strict")) {
strict = 1;
continue;
}
if (!prefixcmp(arg, "--timeout=")) {
timeout = atoi(arg+10);
daemon_mode = 1;
continue;
}
if (!strcmp(arg, "--")) {
i++;
break;
}
}
if (i != argc-1)
usage(upload_pack_usage);
setup_path();
dir = argv[i];
if (!enter_repo(dir, strict))
die("'%s' does not appear to be a git repository", dir);
if (is_repository_shallow())
die("attempt to fetch/clone from a shallow repository");
if (getenv("GIT_DEBUG_SEND_PACK"))
debug_fd = atoi(getenv("GIT_DEBUG_SEND_PACK"));
upload_pack();
return 0;
}
int cmd_main(int argc, const char **argv)
{
const char *dir;
int strict = 0;
struct option options[] = {
OPT_BOOL(0, "stateless-rpc", &stateless_rpc,
N_("quit after a single request/response exchange")),
OPT_BOOL(0, "advertise-refs", &advertise_refs,
N_("exit immediately after intial ref advertisement")),
OPT_BOOL(0, "strict", &strict,
N_("do not try <directory>/.git/ if <directory> is no Git directory")),
OPT_INTEGER(0, "timeout", &timeout,
N_("interrupt transfer after <n> seconds of inactivity")),
OPT_END()
};
packet_trace_identity("upload-pack");
check_replace_refs = 0;
argc = parse_options(argc, argv, NULL, options, upload_pack_usage, 0);
if (argc != 1)
usage_with_options(upload_pack_usage, options);
if (timeout)
daemon_mode = 1;
setup_path();
dir = argv[0];
if (!enter_repo(dir, strict))
die("'%s' does not appear to be a git repository", dir);
git_config(upload_pack_config, NULL);
upload_pack();
return 0;
}
int cmd_receive_pack(int argc, const char **argv, const char *prefix)
{
int advertise_refs = 0;
int i;
struct command *commands;
struct sha1_array shallow = SHA1_ARRAY_INIT;
struct sha1_array ref = SHA1_ARRAY_INIT;
struct shallow_info si;
packet_trace_identity("receive-pack");
argv++;
for (i = 1; i < argc; i++) {
const char *arg = *argv++;
if (*arg == '-') {
if (!strcmp(arg, "--quiet")) {
quiet = 1;
continue;
}
if (!strcmp(arg, "--advertise-refs")) {
advertise_refs = 1;
continue;
}
if (!strcmp(arg, "--stateless-rpc")) {
stateless_rpc = 1;
continue;
}
if (!strcmp(arg, "--reject-thin-pack-for-testing")) {
fix_thin = 0;
continue;
}
usage(receive_pack_usage);
}
if (service_dir)
usage(receive_pack_usage);
service_dir = arg;
}
if (!service_dir)
usage(receive_pack_usage);
setup_path();
if (!enter_repo(service_dir, 0))
die("'%s' does not appear to be a git repository", service_dir);
git_config(receive_pack_config, NULL);
if (cert_nonce_seed)
push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
if (0 <= transfer_unpack_limit)
unpack_limit = transfer_unpack_limit;
else if (0 <= receive_unpack_limit)
unpack_limit = receive_unpack_limit;
if (advertise_refs || !stateless_rpc) {
write_head_info();
}
if (advertise_refs)
return 0;
if ((commands = read_head_info(&shallow)) != NULL) {
const char *unpack_status = NULL;
prepare_shallow_info(&si, &shallow);
if (!si.nr_ours && !si.nr_theirs)
shallow_update = 0;
if (!delete_only(commands)) {
unpack_status = unpack_with_sideband(&si);
update_shallow_info(commands, &si, &ref);
}
execute_commands(commands, unpack_status, &si);
if (pack_lockfile)
unlink_or_warn(pack_lockfile);
if (report_status)
report(commands, unpack_status);
run_receive_hook(commands, "post-receive", 1);
run_update_post_hook(commands);
if (auto_gc) {
const char *argv_gc_auto[] = {
"gc", "--auto", "--quiet", NULL,
};
int opt = RUN_GIT_CMD | RUN_COMMAND_STDOUT_TO_STDERR;
run_command_v_opt(argv_gc_auto, opt);
}
if (auto_update_server_info)
update_server_info(0);
clear_shallow_info(&si);
}
if (use_sideband)
packet_flush(1);
sha1_array_clear(&shallow);
sha1_array_clear(&ref);
free((void *)push_cert_nonce);
return 0;
}
int main(int argc, char **av)
{
const char **argv = (const char **) av;
const char *cmd;
startup_info = &git_startup_info;
cmd = git_extract_argv0_path(argv[0]);
if (!cmd)
cmd = "git-help";
/*
* Always open file descriptors 0/1/2 to avoid clobbering files
* in die(). It also avoids messing up when the pipes are dup'ed
* onto stdin/stdout/stderr in the child processes we spawn.
*/
sanitize_stdfds();
git_setup_gettext();
/*
* "git-xxxx" is the same as "git xxxx", but we obviously:
*
* - cannot take flags in between the "git" and the "xxxx".
* - cannot execute it externally (since it would just do
* the same thing over again)
*
* So we just directly call the builtin handler, and die if
* that one cannot handle it.
*/
if (starts_with(cmd, "git-")) {
cmd += 4;
argv[0] = cmd;
handle_builtin(argc, argv);
die("cannot handle %s as a builtin", cmd);
}
/* Look for flags.. */
argv++;
argc--;
handle_options(&argv, &argc, NULL);
if (argc > 0) {
if (starts_with(argv[0], "--"))
argv[0] += 2;
} else {
/* The user didn't specify a command; give them help */
commit_pager_choice();
printf("usage: %s\n\n", git_usage_string);
list_common_cmds_help();
printf("\n%s\n", _(git_more_info_string));
exit(1);
}
cmd = argv[0];
/*
* We use PATH to find git commands, but we prepend some higher
* precedence paths: the "--exec-path" option, the GIT_EXEC_PATH
* environment, and the $(gitexecdir) from the Makefile at build
* time.
*/
setup_path();
while (1) {
static int done_help = 0;
static int was_alias = 0;
was_alias = run_argv(&argc, &argv);
if (errno != ENOENT)
break;
if (was_alias) {
fprintf(stderr, "Expansion of alias '%s' failed; "
"'%s' is not a git command\n",
cmd, argv[0]);
exit(1);
}
if (!done_help) {
cmd = argv[0] = help_unknown_cmd(cmd);
done_help = 1;
} else
break;
}
fprintf(stderr, "Failed to run command '%s': %s\n",
cmd, strerror(errno));
return 1;
}
void env_init(const struct config_paths_t *paths /* or NULL */)
{
/*
env_read_only variables can not be altered directly by the user
*/
const wchar_t * const ro_keys[] =
{
L"status",
L"history",
L"version",
L"_",
L"LINES",
L"COLUMNS",
L"PWD",
//L"SHLVL", // will be inserted a bit lower down
L"FISH_VERSION",
};
for (size_t i=0; i < sizeof ro_keys / sizeof *ro_keys; i++)
{
env_read_only.insert(ro_keys[i]);
}
/*
Names of all dynamically calculated variables
*/
env_electric.insert(L"history");
env_electric.insert(L"status");
env_electric.insert(L"umask");
env_electric.insert(L"COLUMNS");
env_electric.insert(L"LINES");
top = new env_node_t;
global_env = top;
global = &top->env;
/*
Now the environemnt variable handling is set up, the next step
is to insert valid data
*/
/*
Import environment variables
*/
for (char **p = (environ ? environ : __environ); p && *p; p++)
{
const wcstring key_and_val = str2wcstring(*p); //like foo=bar
size_t eql = key_and_val.find(L'=');
if (eql == wcstring::npos)
{
// no equals found
if (is_read_only(key_and_val) || is_electric(key_and_val)) continue;
env_set(key_and_val, L"", ENV_EXPORT | ENV_GLOBAL);
}
else
{
wcstring key = key_and_val.substr(0, eql);
if (is_read_only(key) || is_electric(key)) continue;
wcstring val = key_and_val.substr(eql + 1);
if (variable_is_colon_delimited_array(key))
{
std::replace(val.begin(), val.end(), L':', ARRAY_SEP);
}
env_set(key, val.c_str(), ENV_EXPORT | ENV_GLOBAL);
}
}
/* Set the given paths in the environment, if we have any */
if (paths != NULL)
{
env_set(FISH_DATADIR_VAR, paths->data.c_str(), ENV_GLOBAL);
env_set(FISH_SYSCONFDIR_VAR, paths->sysconf.c_str(), ENV_GLOBAL);
env_set(FISH_HELPDIR_VAR, paths->doc.c_str(), ENV_GLOBAL);
env_set(FISH_BIN_DIR, paths->bin.c_str(), ENV_GLOBAL);
}
/*
Set up the PATH variable
*/
setup_path();
/*
Set up the USER variable
*/
if (env_get_string(L"USER").missing_or_empty())
{
const struct passwd *pw = getpwuid(getuid());
if (pw && pw->pw_name)
{
const wcstring uname = str2wcstring(pw->pw_name);
env_set(L"USER", uname.c_str(), ENV_GLOBAL | ENV_EXPORT);
}
}
/*
Set up the version variables
*/
wcstring version = str2wcstring(get_fish_version());
env_set(L"version", version.c_str(), ENV_GLOBAL);
env_set(L"FISH_VERSION", version.c_str(), ENV_GLOBAL);
/*
Set up SHLVL variable
*/
const env_var_t shlvl_str = env_get_string(L"SHLVL");
wcstring nshlvl_str = L"1";
if (! shlvl_str.missing())
{
wchar_t *end;
long shlvl_i = wcstol(shlvl_str.c_str(), &end, 10);
while (iswspace(*end)) ++end; /* skip trailing whitespace */
if (shlvl_i >= 0 && *end == '\0')
{
nshlvl_str = to_string<long>(shlvl_i + 1);
}
}
env_set(L"SHLVL", nshlvl_str.c_str(), ENV_GLOBAL | ENV_EXPORT);
env_read_only.insert(L"SHLVL");
/* Set up the HOME variable */
if (env_get_string(L"HOME").missing_or_empty())
{
const env_var_t unam = env_get_string(L"USER");
char *unam_narrow = wcs2str(unam.c_str());
struct passwd *pw = getpwnam(unam_narrow);
if (pw->pw_dir != NULL)
{
const wcstring dir = str2wcstring(pw->pw_dir);
env_set(L"HOME", dir.c_str(), ENV_GLOBAL | ENV_EXPORT);
}
free(unam_narrow);
}
/* Set PWD */
env_set_pwd();
/* Set up universal variables. The empty string means to use the deafult path. */
assert(s_universal_variables == NULL);
s_universal_variables = new env_universal_t(L"");
s_universal_variables->load();
/* Set g_log_forks */
env_var_t log_forks = env_get_string(L"fish_log_forks");
g_log_forks = ! log_forks.missing_or_empty() && from_string<bool>(log_forks);
/* Set g_use_posix_spawn. Default to true. */
env_var_t use_posix_spawn = env_get_string(L"fish_use_posix_spawn");
g_use_posix_spawn = (use_posix_spawn.missing_or_empty() ? true : from_string<bool>(use_posix_spawn));
/* Set fish_bind_mode to "default" */
env_set(FISH_BIND_MODE_VAR, DEFAULT_BIND_MODE, ENV_GLOBAL);
/*
Now that the global scope is fully initialized, add a toplevel local
scope. This same local scope will persist throughout the lifetime of the
fish process, and it will ensure that `set -l` commands run at the
command-line don't affect the global scope.
*/
env_push(false);
}
int main(int argc, const char **argv)
{
int err;
const char *cmd;
char sbuf[STRERR_BUFSIZE];
int value;
/* libsubcmd init */
exec_cmd_init("perf", PREFIX, PERF_EXEC_PATH, EXEC_PATH_ENVIRONMENT);
pager_init(PERF_PAGER_ENVIRONMENT);
/* The page_size is placed in util object. */
page_size = sysconf(_SC_PAGE_SIZE);
cache_line_size(&cacheline_size);
if (sysctl__read_int("kernel/perf_event_max_stack", &value) == 0)
sysctl_perf_event_max_stack = value;
if (sysctl__read_int("kernel/perf_event_max_contexts_per_stack", &value) == 0)
sysctl_perf_event_max_contexts_per_stack = value;
cmd = extract_argv0_path(argv[0]);
if (!cmd)
cmd = "perf-help";
srandom(time(NULL));
perf_config__init();
err = perf_config(perf_default_config, NULL);
if (err)
return err;
set_buildid_dir(NULL);
/* get debugfs/tracefs mount point from /proc/mounts */
tracing_path_mount();
/*
* "perf-xxxx" is the same as "perf xxxx", but we obviously:
*
* - cannot take flags in between the "perf" and the "xxxx".
* - cannot execute it externally (since it would just do
* the same thing over again)
*
* So we just directly call the internal command handler. If that one
* fails to handle this, then maybe we just run a renamed perf binary
* that contains a dash in its name. To handle this scenario, we just
* fall through and ignore the "xxxx" part of the command string.
*/
if (strstarts(cmd, "perf-")) {
cmd += 5;
argv[0] = cmd;
handle_internal_command(argc, argv);
/*
* If the command is handled, the above function does not
* return undo changes and fall through in such a case.
*/
cmd -= 5;
argv[0] = cmd;
}
if (strstarts(cmd, "trace")) {
#if defined(HAVE_LIBAUDIT_SUPPORT) || defined(HAVE_SYSCALL_TABLE_SUPPORT)
setup_path();
argv[0] = "trace";
return cmd_trace(argc, argv);
#else
fprintf(stderr,
"trace command not available: missing audit-libs devel package at build time.\n");
goto out;
#endif
}
/* Look for flags.. */
argv++;
argc--;
handle_options(&argv, &argc, NULL);
commit_pager_choice();
if (argc > 0) {
if (strstarts(argv[0], "--"))
argv[0] += 2;
} else {
/* The user didn't specify a command; give them help */
printf("\n usage: %s\n\n", perf_usage_string);
list_common_cmds_help();
printf("\n %s\n\n", perf_more_info_string);
goto out;
}
cmd = argv[0];
test_attr__init();
/*
* We use PATH to find perf commands, but we prepend some higher
* precedence paths: the "--exec-path" option, the PERF_EXEC_PATH
* environment, and the $(perfexecdir) from the Makefile at build
* time.
*/
setup_path();
/*
* Block SIGWINCH notifications so that the thread that wants it can
* unblock and get syscalls like select interrupted instead of waiting
* forever while the signal goes to some other non interested thread.
*/
pthread__block_sigwinch();
perf_debug_setup();
while (1) {
static int done_help;
run_argv(&argc, &argv);
if (errno != ENOENT)
break;
if (!done_help) {
cmd = argv[0] = help_unknown_cmd(cmd);
done_help = 1;
} else
break;
}
fprintf(stderr, "Failed to run command '%s': %s\n",
cmd, str_error_r(errno, sbuf, sizeof(sbuf)));
out:
return 1;
}
int main(int argc, const char **argv)
{
const char *cmd;
cmd = perf_extract_argv0_path(argv[0]);
if (!cmd)
cmd = "perf-help";
debugfs_mount(NULL);
if (!prefixcmp(cmd, "perf-")) {
cmd += 5;
argv[0] = cmd;
handle_internal_command(argc, argv);
die("cannot handle %s internally", cmd);
}
argv++;
argc--;
handle_options(&argv, &argc, NULL);
commit_pager_choice();
set_buildid_dir();
if (argc > 0) {
if (!prefixcmp(argv[0], "--"))
argv[0] += 2;
} else {
printf("\n usage: %s\n\n", perf_usage_string);
list_common_cmds_help();
printf("\n %s\n\n", perf_more_info_string);
exit(1);
}
cmd = argv[0];
setup_path();
pthread__block_sigwinch();
while (1) {
static int done_help;
static int was_alias;
was_alias = run_argv(&argc, &argv);
if (errno != ENOENT)
break;
if (was_alias) {
fprintf(stderr, "Expansion of alias '%s' failed; "
"'%s' is not a perf-command\n",
cmd, argv[0]);
exit(1);
}
if (!done_help) {
cmd = argv[0] = help_unknown_cmd(cmd);
done_help = 1;
} else
break;
}
fprintf(stderr, "Failed to run command '%s': %s\n",
cmd, strerror(errno));
return 1;
}
void env_init(const struct config_paths_t *paths /* or NULL */)
{
/*
env_read_only variables can not be altered directly by the user
*/
const wchar_t * const ro_keys[] =
{
L"status",
L"history",
L"version",
L"_",
L"LINES",
L"COLUMNS",
L"PWD",
L"SHLVL",
L"FISH_VERSION",
};
for (size_t i=0; i < sizeof ro_keys / sizeof *ro_keys; i++)
{
env_read_only.insert(ro_keys[i]);
}
/*
HOME and USER should be writeable by root, since this can be a
convenient way to install software.
*/
if (getuid() != 0)
{
env_read_only.insert(L"HOME");
env_read_only.insert(L"USER");
}
/*
Names of all dynamically calculated variables
*/
env_electric.insert(L"history");
env_electric.insert(L"status");
env_electric.insert(L"umask");
top = new env_node_t;
global_env = top;
global = &top->env;
/*
Now the environemnt variable handling is set up, the next step
is to insert valid data
*/
/*
Import environment variables
*/
for (char **p = (environ ? environ : __environ); p && *p; p++)
{
const wcstring key_and_val = str2wcstring(*p); //like foo=bar
size_t eql = key_and_val.find(L'=');
if (eql == wcstring::npos)
{
// no equals found
env_set(key_and_val, L"", ENV_EXPORT);
}
else
{
wcstring key = key_and_val.substr(0, eql);
wcstring val = key_and_val.substr(eql + 1);
if (variable_can_be_array(val))
{
std::replace(val.begin(), val.end(), L':', ARRAY_SEP);
}
env_set(key, val.c_str(), ENV_EXPORT | ENV_GLOBAL);
}
}
/* Set the given paths in the environment, if we have any */
if (paths != NULL)
{
env_set(FISH_DATADIR_VAR, paths->data.c_str(), ENV_GLOBAL | ENV_EXPORT);
env_set(FISH_SYSCONFDIR_VAR, paths->sysconf.c_str(), ENV_GLOBAL | ENV_EXPORT);
env_set(FISH_HELPDIR_VAR, paths->doc.c_str(), ENV_GLOBAL | ENV_EXPORT);
env_set(FISH_BIN_DIR, paths->bin.c_str(), ENV_GLOBAL | ENV_EXPORT);
}
/*
Set up the PATH variable
*/
setup_path();
/*
Set up the USER variable
*/
const struct passwd *pw = getpwuid(getuid());
if (pw && pw->pw_name)
{
const wcstring uname = str2wcstring(pw->pw_name);
env_set(L"USER", uname.c_str(), ENV_GLOBAL | ENV_EXPORT);
}
/*
Set up the version variables
*/
wcstring version = str2wcstring(FISH_BUILD_VERSION);
env_set(L"version", version.c_str(), ENV_GLOBAL);
env_set(L"FISH_VERSION", version.c_str(), ENV_GLOBAL);
const env_var_t fishd_dir_wstr = env_get_string(L"FISHD_SOCKET_DIR");
const env_var_t user_dir_wstr = env_get_string(L"USER");
wchar_t * fishd_dir = fishd_dir_wstr.missing()?NULL:const_cast<wchar_t*>(fishd_dir_wstr.c_str());
wchar_t * user_dir = user_dir_wstr.missing()?NULL:const_cast<wchar_t*>(user_dir_wstr.c_str());
env_universal_init(fishd_dir , user_dir ,
&start_fishd,
&universal_callback);
/*
Set up SHLVL variable
*/
const env_var_t shlvl_str = env_get_string(L"SHLVL");
wcstring nshlvl_str = L"1";
if (! shlvl_str.missing())
{
long shlvl_i = wcstol(shlvl_str.c_str(), NULL, 10);
if (shlvl_i >= 0)
{
nshlvl_str = to_string<long>(shlvl_i + 1);
}
}
env_set(L"SHLVL", nshlvl_str.c_str(), ENV_GLOBAL | ENV_EXPORT);
/* Set correct defaults for e.g. USER and HOME variables */
env_set_defaults();
/* Set g_log_forks */
env_var_t log_forks = env_get_string(L"fish_log_forks");
g_log_forks = ! log_forks.missing_or_empty() && from_string<bool>(log_forks);
/* Set g_use_posix_spawn. Default to true. */
env_var_t use_posix_spawn = env_get_string(L"fish_use_posix_spawn");
g_use_posix_spawn = (use_posix_spawn.missing_or_empty() ? true : from_string<bool>(use_posix_spawn));
}
void env_init(const struct config_paths_t *paths /* or NULL */)
{
char **p;
struct passwd *pw;
wchar_t *uname;
wchar_t *version;
/*
env_read_only variables can not be altered directly by the user
*/
const wchar_t * const ro_keys[] = {
L"status",
L"history",
L"version",
L"_",
L"LINES",
L"COLUMNS",
L"PWD",
L"SHLVL",
};
for (size_t i=0; i < sizeof ro_keys / sizeof *ro_keys; i++) {
env_read_only.insert(ro_keys[i]);
}
/*
HOME and USER should be writeable by root, since this can be a
convenient way to install software.
*/
if( getuid() != 0 )
{
env_read_only.insert(L"HOME");
env_read_only.insert(L"USER");
}
/*
Names of all dynamically calculated variables
*/
env_electric.insert(L"history");
env_electric.insert(L"status");
env_electric.insert(L"umask");
top = new env_node_t;
global_env = top;
global = &top->env;
/*
Now the environemnt variable handling is set up, the next step
is to insert valid data
*/
/*
Import environment variables
*/
for( p=environ?environ:__environ; p && *p; p++ )
{
wchar_t *key, *val;
key = str2wcs(*p);
if( !key )
{
continue;
}
val = wcschr( key, L'=' );
if( val == 0 )
{
env_set( key, L"", ENV_EXPORT );
}
else
{
*val = L'\0';
val++;
//fwprintf( stderr, L"Set $%ls to %ls\n", key, val );
if (variable_can_be_array(val)) {
for (size_t i=0; val[i] != L'\0'; i++) {
if( val[i] == L':' ) {
val[i] = ARRAY_SEP;
}
}
}
env_set( key, val, ENV_EXPORT | ENV_GLOBAL );
}
free(key);
}
/* Set the given paths in the environment, if we have any */
if (paths != NULL)
{
env_set(FISH_DATADIR_VAR, paths->data.c_str(), ENV_GLOBAL | ENV_EXPORT);
env_set(FISH_SYSCONFDIR_VAR, paths->sysconf.c_str(), ENV_GLOBAL | ENV_EXPORT);
env_set(FISH_HELPDIR_VAR, paths->doc.c_str(), ENV_GLOBAL | ENV_EXPORT);
env_set(FISH_BIN_DIR, paths->bin.c_str(), ENV_GLOBAL | ENV_EXPORT);
}
/*
Set up the PATH variable
*/
setup_path();
/*
Set up the USER variable
*/
pw = getpwuid( getuid() );
if( pw )
{
uname = str2wcs( pw->pw_name );
env_set( L"USER", uname, ENV_GLOBAL | ENV_EXPORT );
free( uname );
}
/*
Set up the version variable
*/
version = str2wcs( PACKAGE_VERSION );
env_set( L"version", version, ENV_GLOBAL );
free( version );
const env_var_t fishd_dir_wstr = env_get_string( L"FISHD_SOCKET_DIR");
const env_var_t user_dir_wstr = env_get_string( L"USER" );
wchar_t * fishd_dir = fishd_dir_wstr.missing()?NULL:const_cast<wchar_t*>(fishd_dir_wstr.c_str());
wchar_t * user_dir = user_dir_wstr.missing()?NULL:const_cast<wchar_t*>(user_dir_wstr.c_str());
env_universal_init(fishd_dir , user_dir ,
&start_fishd,
&universal_callback );
/*
Set up SHLVL variable
*/
const env_var_t shlvl_str = env_get_string( L"SHLVL" );
wcstring nshlvl_str = L"1";
if (! shlvl_str.missing())
{
long shlvl_i = wcstol(shlvl_str.c_str(), NULL, 10);
if (shlvl_i >= 0)
{
nshlvl_str = format_string(L"%ld", 1 + shlvl_i);
}
}
env_set(L"SHLVL", nshlvl_str.c_str(), ENV_GLOBAL | ENV_EXPORT );
/* Set correct defaults for e.g. USER and HOME variables */
env_set_defaults();
/* Set g_log_forks */
env_var_t log_forks = env_get_string(L"fish_log_forks");
g_log_forks = ! log_forks.missing_or_empty() && from_string<bool>(log_forks);
/* Set g_use_posix_spawn. Default to true. */
env_var_t use_posix_spawn = env_get_string(L"fish_use_posix_spawn");
g_use_posix_spawn = (use_posix_spawn.missing_or_empty() ? true : from_string<bool>(use_posix_spawn));
}
/*--------------------------------------------------------------*/
int main(void)
{
setup(); /* temp file is now open */
npathdats = (sizeof(pathdat) / sizeof(pathdat[0]));
ngoods = (sizeof(goodlist) / sizeof(goodlist[0]));
nbads = (sizeof(badlist) / sizeof(badlist[0]));
nmnem = (sizeof(mnem) / sizeof(mnem[0]));
setup_path();
/*---------------- ENTER BLOCK 0 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall recursively descend the\n");
fprintf(temp, "directory hierarchy rooted in path until it has\n");
fprintf(temp,
"traversed the whole tree, calling the function fn for\n");
fprintf(temp, "each object in the directory tree, and return 0.\n\n");
#endif
test1A();
blexit();
/*--------------- EXIT BLOCK 0 ---------------------------------*/
/*---------------- ENTER BLOCK 1 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) when flags contains FTW_PHYS shall\n");
fprintf(temp, "not traverse symbolic links.\n\n");
#endif
test2A();
blexit();
/*--------------- EXIT BLOCK 1 ---------------------------------*/
/*---------------- ENTER BLOCK 2 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp,
"depth, int flags) when flags does not contain FTW_PHYS\n");
fprintf(temp,
"shall follow links instead of reporting them and shall\n");
fprintf(temp, "not report the same file twice.\n\n");
#endif
test3A();
blexit();
/*--------------- EXIT BLOCK 2 ---------------------------------*/
/*---------------- ENTER BLOCK 3 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp,
"depth, int flags) when flags contains FTW_DEPTH shall\n");
fprintf(temp, "report all files in a directory before reporting the\n");
fprintf(temp, "directory.\n\n");
#endif
test4A();
blexit();
/*--------------- EXIT BLOCK 3 ---------------------------------*/
/*---------------- ENTER BLOCK 4 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) when flags does not contain\n");
fprintf(temp, "FTW_DEPTH shall report a directory before reporting\n");
fprintf(temp, "the files in that directory.\n\n");
#endif
test5A();
blexit();
/*--------------- EXIT BLOCK 4 ---------------------------------*/
/*---------------- ENTER BLOCK 5 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp,
"depth, int flags) when flags contains FTW_CHDIR shall\n");
fprintf(temp,
"change the current working directory to each directory\n");
fprintf(temp, "as it reports files in that directory.\n\n");
#endif
test6A();
blexit();
/*--------------- EXIT BLOCK 5 ---------------------------------*/
/*---------------- ENTER BLOCK 6 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass the path-name of the\n");
fprintf(temp, "current object as the first argument of the function\n");
fprintf(temp, "fn.\n\n");
#endif
test7A();
blexit();
/*--------------- EXIT BLOCK 6 ---------------------------------*/
/*---------------- ENTER BLOCK 7 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass a pointer to a stat\n");
fprintf(temp, "structure containing information about the current\n");
fprintf(temp, "object as the second argument to fn.\n\n");
#endif
test8A();
blexit();
/*--------------- EXIT BLOCK 7 ---------------------------------*/
/*---------------- ENTER BLOCK 8 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass FTW_F as the third\n");
fprintf(temp,
"argument of the function fn when the object is a file.\n\n");
#endif
test9A();
blexit();
/*--------------- EXIT BLOCK 8 ---------------------------------*/
/*---------------- ENTER BLOCK 9 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass FTW_D as the third\n");
fprintf(temp, "argument of the function fn when the object is a\n");
fprintf(temp, "directory.\n\n");
#endif
test10A();
blexit();
/*--------------- EXIT BLOCK 9 ---------------------------------*/
/*---------------- ENTER BLOCK 10 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass FTW_DP as the third\n");
fprintf(temp, "argument of the function fn when the object is a\n");
fprintf(temp, "directory and subdirectories have been visited.\n\n");
#endif
test11A();
blexit();
/*--------------- EXIT BLOCK 10 ---------------------------------*/
/*---------------- ENTER BLOCK 11 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass FTW_SL as the third\n");
fprintf(temp, "argument of the function fn when the object is a\n");
fprintf(temp, "symbolic link.\n\n");
#endif
test12A();
blexit();
/*--------------- EXIT BLOCK 11 ---------------------------------*/
/*---------------- ENTER BLOCK 12 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass FTW_SLN as the third\n");
fprintf(temp, "argument of the function fn when the object is a\n");
fprintf(temp, "symbolic link that does not name an existing file.\n\n");
#endif
test13A();
blexit();
/*--------------- EXIT BLOCK 12 ---------------------------------*/
/*---------------- ENTER BLOCK 13 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass FTW_DNR as the third\n");
fprintf(temp, "argument of the function fn when the object is a\n");
fprintf(temp, "directory that cannot be read.\n\n");
#endif
test14A();
blexit();
/*--------------- EXIT BLOCK 13 ---------------------------------*/
/*---------------- ENTER BLOCK 14 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass FTW_NS as the third\n");
fprintf(temp,
"argument of the function fn when stat() failed on the\n");
fprintf(temp, "object because of lack of appropriate permission.\n\n");
#endif
test15A();
blexit();
/*--------------- EXIT BLOCK 14 ---------------------------------*/
/*---------------- ENTER BLOCK 15 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass a structure which\n");
fprintf(temp, "contains the offset into the pathname of the object\n");
fprintf(temp, "and the depth relative to the root of the walk\n");
fprintf(temp,
"starting from 0 as the fourth argument of the function\n");
fprintf(temp, "fn.\n\n");
#endif
test16A();
blexit();
/*--------------- EXIT BLOCK 15 ---------------------------------*/
/*---------------- ENTER BLOCK 16 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass FTW_SL as the third\n");
fprintf(temp, "argument to the function fn if and only if the\n");
fprintf(temp, "FTW_PHYS flag is included in flags.\n\n");
#endif
test17A();
blexit();
/*--------------- EXIT BLOCK 16 ---------------------------------*/
/*---------------- ENTER BLOCK 17 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall pass FTW_SLN as the third\n");
fprintf(temp, "argument to the function fn if and only if the\n");
fprintf(temp, "FTW_PHYS flag is not included in flags.\n\n");
#endif
test18A();
blexit();
/*--------------- EXIT BLOCK 17 ---------------------------------*/
/*---------------- ENTER BLOCK 18 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "On a call to int nftw(const char *path, int\n");
fprintf(temp, "(*fn)(const char *, const struct stat *, int, struct\n");
fprintf(temp,
"FTW *), int depth, int flags) when the third argument\n");
fprintf(temp, "passed to the function fn is FTW_DNR then the\n");
fprintf(temp,
"descendants of the directory shall not be processed.\n\n");
#endif
test19A();
blexit();
/*--------------- EXIT BLOCK 18 ---------------------------------*/
/*---------------- ENTER BLOCK 19 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp,
"depth, int flags) shall close any file descriptors or\n");
fprintf(temp,
"directory streams used to traverse the directory tree.\n\n");
#endif
test20A();
blexit();
/*--------------- EXIT BLOCK 19 ---------------------------------*/
/*---------------- ENTER BLOCK 20 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "On a call to int nftw(const char *path, int\n");
fprintf(temp, "(*fn)(const char *, const struct stat *, int, struct\n");
fprintf(temp, "FTW *), int depth, int flags) depth shall be the\n");
fprintf(temp,
"maximum number of file descriptors used for the search.\n\n");
#endif
test21A();
blexit();
/*--------------- EXIT BLOCK 20 ---------------------------------*/
/*---------------- ENTER BLOCK 21 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) shall use at most one file\n");
fprintf(temp, "descriptor for each directory level.\n\n");
#endif
test22A();
blexit();
/*--------------- EXIT BLOCK 21 ---------------------------------*/
/*---------------- ENTER BLOCK 22 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "A call to int nftw(const char *path, int (*fn)(const\n");
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
fprintf(temp, "depth, int flags) when the function fn returns a\n");
fprintf(temp, "non-zero value shall stop and return the value\n");
fprintf(temp, "returned by fn.\n\n");
#endif
test23A();
blexit();
/*--------------- EXIT BLOCK 22 ---------------------------------*/
/*---------------- ENTER BLOCK 23 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "ENAMETOOLONG in errno and return -1 on a call to int\n");
fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
fprintf(temp, "flags) when the length of path exceeds PATH_MAX.\n\n");
#endif
test24A();
blexit();
/*--------------- EXIT BLOCK 23 ---------------------------------*/
/*---------------- ENTER BLOCK 24 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "ENAMETOOLONG in errno and return -1 on a call to int\n");
fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
fprintf(temp, "flags) when a component of path exceeds NAME_MAX.\n\n");
#endif
test25A();
blexit();
/*--------------- EXIT BLOCK 24 ---------------------------------*/
/*---------------- ENTER BLOCK 25 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "ENOENT in errno and return -1 on a call to int\n");
fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
fprintf(temp,
"flags) when path points to a file which does not exist.\n\n");
#endif
test26A();
blexit();
/*--------------- EXIT BLOCK 25 ---------------------------------*/
/*---------------- ENTER BLOCK 26 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "ENOENT in errno and return -1 on a call to int\n");
fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
fprintf(temp, "flags) when path points to an empty string.\n\n");
#endif
test27A();
blexit();
/*--------------- EXIT BLOCK 26 ---------------------------------*/
/*---------------- ENTER BLOCK 27 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "ENOTDIR in errno and return -1 on a call to int\n");
fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
fprintf(temp, "flags) when path is not a directory.\n\n");
#endif
test28A();
blexit();
/*--------------- EXIT BLOCK 27 ---------------------------------*/
/*---------------- ENTER BLOCK 28 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "EACCES in errno and return -1 on a call to int\n");
fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
fprintf(temp, "flags) when search permission is denied for any\n");
fprintf(temp, "component of path.\n\n");
#endif
test29A();
blexit();
/*--------------- EXIT BLOCK 28 ---------------------------------*/
/*---------------- ENTER BLOCK 29 --------------------------------*/
blenter();
#ifdef DEBUG
fprintf(temp, "EACCES in errno and return -1 on a call to int\n");
fprintf(temp, "nftw(const char *path, int (*fn)(const char *, const\n");
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
fprintf(temp, "flags) when read permission is denied for path.\n\n");
#endif
test30A();
blexit();
/*--------------- EXIT BLOCK 29 ---------------------------------*/
cleanup_function();
anyfail(); /* THIS CALL DOES NOT RETURN - EXITS!! */
tst_exit();
/*--------------------------------------------------------------*/
}
int main(int argc, const char **argv)
{
const char *cmd;
startup_info = &git_startup_info;
cmd = git_extract_argv0_path(argv[0]);
if (!cmd)
cmd = "git-help";
/*
* "git-xxxx" is the same as "git xxxx", but we obviously:
*
* - cannot take flags in between the "git" and the "xxxx".
* - cannot execute it externally (since it would just do
* the same thing over again)
*
* So we just directly call the internal command handler, and
* die if that one cannot handle it.
*/
if (!prefixcmp(cmd, "git-")) {
cmd += 4;
argv[0] = cmd;
handle_internal_command(argc, argv);
die("cannot handle %s internally", cmd);
}
/* Look for flags.. */
argv++;
argc--;
handle_options(&argv, &argc, NULL);
if (argc > 0) {
if (!prefixcmp(argv[0], "--"))
argv[0] += 2;
} else {
/* The user didn't specify a command; give them help */
commit_pager_choice();
printf("usage: %s\n\n", git_usage_string);
list_common_cmds_help();
printf("\n%s\n", git_more_info_string);
exit(1);
}
cmd = argv[0];
/*
* We use PATH to find git commands, but we prepend some higher
* precedence paths: the "--exec-path" option, the GIT_EXEC_PATH
* environment, and the $(gitexecdir) from the Makefile at build
* time.
*/
setup_path();
while (1) {
static int done_help = 0;
static int was_alias = 0;
was_alias = run_argv(&argc, &argv);
if (errno != ENOENT)
break;
if (was_alias) {
fprintf(stderr, "Expansion of alias '%s' failed; "
"'%s' is not a git command\n",
cmd, argv[0]);
exit(1);
}
if (!done_help) {
cmd = argv[0] = help_unknown_cmd(cmd);
done_help = 1;
} else
break;
}
fprintf(stderr, "Failed to run command '%s': %s\n",
cmd, strerror(errno));
return 1;
}
int main(int argc, char **argv)
{
char *method = getenv("REQUEST_METHOD");
char *dir;
struct service_cmd *cmd = NULL;
char *cmd_arg = NULL;
int i;
git_setup_gettext();
git_extract_argv0_path(argv[0]);
set_die_routine(die_webcgi);
if (!method)
die("No REQUEST_METHOD from server");
if (!strcmp(method, "HEAD"))
method = "GET";
dir = getdir();
for (i = 0; i < ARRAY_SIZE(services); i++) {
struct service_cmd *c = &services[i];
regex_t re;
regmatch_t out[1];
if (regcomp(&re, c->pattern, REG_EXTENDED))
die("Bogus regex in service table: %s", c->pattern);
if (!regexec(&re, dir, 1, out, 0)) {
size_t n;
if (strcmp(method, c->method)) {
const char *proto = getenv("SERVER_PROTOCOL");
if (proto && !strcmp(proto, "HTTP/1.1")) {
http_status(405, "Method Not Allowed");
hdr_str("Allow", !strcmp(c->method, "GET") ?
"GET, HEAD" : c->method);
} else
http_status(400, "Bad Request");
hdr_nocache();
end_headers();
return 0;
}
cmd = c;
n = out[0].rm_eo - out[0].rm_so;
cmd_arg = xmemdupz(dir + out[0].rm_so + 1, n - 1);
dir[out[0].rm_so] = 0;
break;
}
regfree(&re);
}
if (!cmd)
not_found("Request not supported: '%s'", dir);
setup_path();
if (!enter_repo(dir, 0))
not_found("Not a git repository: '%s'", dir);
if (!getenv("GIT_HTTP_EXPORT_ALL") &&
access("git-daemon-export-ok", F_OK) )
not_found("Repository not exported: '%s'", dir);
git_config(http_config, NULL);
cmd->imp(cmd_arg);
return 0;
}
int main(int argc, const char **argv)
{
const char *cmd;
cmd = perf_extract_argv0_path(argv[0]);
if (!cmd)
cmd = "perf-help";
if(adj_oom_score())
die("Cannot adjust my oom_adj, pls make sure you are root \
or have CAP_SYS_RESOURCE");
/* get debugfs mount point from /proc/mounts */
debugfs_mount(NULL);
/*
* "perf-xxxx" is the same as "perf xxxx", but we obviously:
*
* - cannot take flags in between the "perf" and the "xxxx".
* - cannot execute it externally (since it would just do
* the same thing over again)
*
* So we just directly call the internal command handler, and
* die if that one cannot handle it.
*/
if (!prefixcmp(cmd, "perf-")) {
cmd += 5;
argv[0] = cmd;
handle_internal_command(argc, argv);
die("cannot handle %s internally", cmd);
}
/* Look for flags.. */
argv++;
argc--;
handle_options(&argv, &argc, NULL);
commit_pager_choice();
set_buildid_dir();
if (argc > 0) {
if (!prefixcmp(argv[0], "--"))
argv[0] += 2;
} else {
/* The user didn't specify a command; give them help */
printf("\n usage: %s\n\n", perf_usage_string);
list_common_cmds_help();
printf("\n %s\n\n", perf_more_info_string);
exit(1);
}
cmd = argv[0];
/*
* We use PATH to find perf commands, but we prepend some higher
* precedence paths: the "--exec-path" option, the PERF_EXEC_PATH
* environment, and the $(perfexecdir) from the Makefile at build
* time.
*/
setup_path();
/*
* Block SIGWINCH notifications so that the thread that wants it can
* unblock and get syscalls like select interrupted instead of waiting
* forever while the signal goes to some other non interested thread.
*/
pthread__block_sigwinch();
while (1) {
static int done_help;
static int was_alias;
was_alias = run_argv(&argc, &argv);
if (errno != ENOENT)
break;
if (was_alias) {
fprintf(stderr, "Expansion of alias '%s' failed; "
"'%s' is not a perf-command\n",
cmd, argv[0]);
exit(1);
}
if (!done_help) {
cmd = argv[0] = help_unknown_cmd(cmd);
done_help = 1;
} else
break;
}
fprintf(stderr, "Failed to run command '%s': %s\n",
cmd, strerror(errno));
return 1;
}
int cmd_receive_pack(int argc, const char **argv, const char *prefix)
{
int advertise_refs = 0;
struct command *commands;
struct sha1_array shallow = SHA1_ARRAY_INIT;
struct sha1_array ref = SHA1_ARRAY_INIT;
struct shallow_info si;
struct option options[] = {
OPT__QUIET(&quiet, N_("quiet")),
OPT_HIDDEN_BOOL(0, "stateless-rpc", &stateless_rpc, NULL),
OPT_HIDDEN_BOOL(0, "advertise-refs", &advertise_refs, NULL),
OPT_HIDDEN_BOOL(0, "reject-thin-pack-for-testing", &reject_thin, NULL),
OPT_END()
};
packet_trace_identity("receive-pack");
argc = parse_options(argc, argv, prefix, options, receive_pack_usage, 0);
if (argc > 1)
usage_msg_opt(_("Too many arguments."), receive_pack_usage, options);
if (argc == 0)
usage_msg_opt(_("You must specify a directory."), receive_pack_usage, options);
service_dir = argv[0];
setup_path();
if (!enter_repo(service_dir, 0))
die("'%s' does not appear to be a git repository", service_dir);
git_config(receive_pack_config, NULL);
if (cert_nonce_seed)
push_cert_nonce = prepare_push_cert_nonce(service_dir, time(NULL));
if (0 <= transfer_unpack_limit)
unpack_limit = transfer_unpack_limit;
else if (0 <= receive_unpack_limit)
unpack_limit = receive_unpack_limit;
if (advertise_refs || !stateless_rpc) {
write_head_info();
}
if (advertise_refs)
return 0;
if ((commands = read_head_info(&shallow)) != NULL) {
const char *unpack_status = NULL;
struct string_list push_options = STRING_LIST_INIT_DUP;
if (use_push_options)
read_push_options(&push_options);
prepare_shallow_info(&si, &shallow);
if (!si.nr_ours && !si.nr_theirs)
shallow_update = 0;
if (!delete_only(commands)) {
unpack_status = unpack_with_sideband(&si);
update_shallow_info(commands, &si, &ref);
}
use_keepalive = KEEPALIVE_ALWAYS;
execute_commands(commands, unpack_status, &si,
&push_options);
if (pack_lockfile)
unlink_or_warn(pack_lockfile);
if (report_status)
report(commands, unpack_status);
run_receive_hook(commands, "post-receive", 1,
&push_options);
run_update_post_hook(commands);
if (push_options.nr)
string_list_clear(&push_options, 0);
if (auto_gc) {
const char *argv_gc_auto[] = {
"gc", "--auto", "--quiet", NULL,
};
struct child_process proc = CHILD_PROCESS_INIT;
proc.no_stdin = 1;
proc.stdout_to_stderr = 1;
proc.err = use_sideband ? -1 : 0;
proc.git_cmd = 1;
proc.argv = argv_gc_auto;
close_all_packs();
if (!start_command(&proc)) {
if (use_sideband)
copy_to_sideband(proc.err, -1, NULL);
finish_command(&proc);
}
}
if (auto_update_server_info)
update_server_info(0);
clear_shallow_info(&si);
}
if (use_sideband)
packet_flush(1);
sha1_array_clear(&shallow);
sha1_array_clear(&ref);
free((void *)push_cert_nonce);
return 0;
}
int main(int argc, char *argv[])
{
bool inhibit_loadfade = false;
bool error = false;
bool freshstart;
if (!setup_path(argc, argv))
return 1;
SetLogFilename("debug.txt");
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
{
staterr("ack, sdl_init failed: %s.", SDL_GetError());
return 1;
}
atexit(SDL_Quit);
// start up inputs first thing because settings_load may remap them
input_init();
// load settings, or at least get the defaults,
// so we know the initial screen resolution.
settings_load();
if (Graphics::init(settings->resolution)) { staterr("Failed to initialize graphics."); return 1; }
if (font_init()) { staterr("Failed to load font."); return 1; }
//speed_test();
//return 1;
#ifdef CONFIG_DATA_EXTRACTOR
if (!settings->files_extracted)
{
if (extract_main())
{
Graphics::close();
font_close();
return 0;
}
else
{
settings->files_extracted = true;
settings_save();
}
}
#endif
if (check_data_exists())
{
return 1;
}
//Graphics::ShowLoadingScreen();
if (sound_init()) { fatal("Failed to initialize sound."); return 1; }
if (trig_init()) { fatal("Failed trig module init."); return 1; }
if (tsc_init()) { fatal("Failed to initialize script engine."); return 1; }
if (textbox.Init()) { fatal("Failed to initialize textboxes."); return 1; }
if (Carets::init()) { fatal("Failed to initialize carets."); return 1; }
#ifdef CONFIG_USE_VJOY
VJoy::Init();
#endif
if (game.init()) return 1;
game.setmode(GM_NORMAL);
// set null stage just to have something to do while we go to intro
game.switchstage.mapno = 0;
//#define REPLAY
#ifdef REPLAY
game.switchstage.mapno = START_REPLAY;
//Replay::set_ffwd(6000);
//Replay::set_stopat(3500);
game.switchstage.param = 1;
#else
//game.switchstage.mapno = LOAD_GAME;
//game.pause(GP_OPTIONS);
if (settings->skip_intro && file_exists(GetProfileName(settings->last_save_slot)))
game.switchstage.mapno = LOAD_GAME;
else
game.setmode(GM_INTRO);
#endif
// for debug
if (game.paused) { game.switchstage.mapno = 0; game.switchstage.eventonentry = 0; }
if (game.switchstage.mapno == LOAD_GAME) inhibit_loadfade = true;
game.running = true;
freshstart = true;
stat("Entering main loop...");
#ifdef __SDLSHIM__
set_console_visible(false);
#endif
//speed_test();
//return 1;
while(game.running)
{
// SSS/SPS persists across stage transitions until explicitly
// stopped, or you die & reload. It seems a bit risky to me,
// but that's the spec.
if (game.switchstage.mapno >= MAPNO_SPECIALS)
{
StopLoopSounds();
}
// enter next stage, whatever it may be
if (game.switchstage.mapno == LOAD_GAME || \
game.switchstage.mapno == LOAD_GAME_FROM_MENU)
{
if (game.switchstage.mapno == LOAD_GAME_FROM_MENU)
freshstart = true;
stat("= Loading game =");
if (game_load(settings->last_save_slot))
{
fatal("savefile error");
goto ingame_error;
}
Replay::OnGameStarting();
if (!inhibit_loadfade) fade.Start(FADE_IN, FADE_CENTER);
else inhibit_loadfade = false;
}
else if (game.switchstage.mapno == START_REPLAY)
{
stat(">> beginning replay '%s'", GetReplayName(game.switchstage.param));
StopScripts();
if (Replay::begin_playback(GetReplayName(game.switchstage.param)))
{
fatal("error starting playback");
goto ingame_error;
}
}
else
{
if (game.switchstage.mapno == NEW_GAME || \
game.switchstage.mapno == NEW_GAME_FROM_MENU)
{
bool show_intro = (game.switchstage.mapno == NEW_GAME_FROM_MENU);
InitNewGame(show_intro);
}
// slide weapon bar on first intro to Start Point
if (game.switchstage.mapno == STAGE_START_POINT && \
game.switchstage.eventonentry == 91)
{
freshstart = true;
}
// switch maps
if (load_stage(game.switchstage.mapno)) goto ingame_error;
player->x = (game.switchstage.playerx * TILE_W) << CSF;
player->y = (game.switchstage.playery * TILE_H) << CSF;
}
// start the level
if (game.initlevel()) return 1;
if (freshstart)
weapon_introslide();
gameloop();
game.stageboss.OnMapExit();
freshstart = false;
}
shutdown: ;
Replay::close();
game.close();
Carets::close();
Graphics::close();
input_close();
font_close();
sound_close();
tsc_close();
textbox.Deinit();
return error;
ingame_error: ;
stat("");
stat(" ************************************************");
stat(" * An in-game error occurred. Game shutting down.");
stat(" ************************************************");
error = true;
goto shutdown;
}
int main(int argc, const char **argv)
{
const char *cmd;
/* The page_size is placed in util object. */
page_size = sysconf(_SC_PAGE_SIZE);
cmd = perf_extract_argv0_path(argv[0]);
if (!cmd)
cmd = "perf-help";
/* get debugfs mount point from /proc/mounts */
perf_debugfs_mount(NULL);
/*
* "perf-xxxx" is the same as "perf xxxx", but we obviously:
*
* - cannot take flags in between the "perf" and the "xxxx".
* - cannot execute it externally (since it would just do
* the same thing over again)
*
* So we just directly call the internal command handler, and
* die if that one cannot handle it.
*/
if (!prefixcmp(cmd, "perf-")) {
cmd += 5;
argv[0] = cmd;
handle_internal_command(argc, argv);
fprintf(stderr, "cannot handle %s internally", cmd);
goto out;
}
if (!prefixcmp(cmd, "trace")) {
#ifdef HAVE_LIBAUDIT_SUPPORT
set_buildid_dir();
setup_path();
argv[0] = "trace";
return cmd_trace(argc, argv, NULL);
#else
fprintf(stderr,
"trace command not available: missing audit-libs devel package at build time.\n");
goto out;
#endif
}
/* Look for flags.. */
argv++;
argc--;
handle_options(&argv, &argc, NULL);
commit_pager_choice();
set_buildid_dir();
if (argc > 0) {
if (!prefixcmp(argv[0], "--"))
argv[0] += 2;
} else {
/* The user didn't specify a command; give them help */
printf("\n usage: %s\n\n", perf_usage_string);
list_common_cmds_help();
printf("\n %s\n\n", perf_more_info_string);
goto out;
}
cmd = argv[0];
test_attr__init();
/*
* We use PATH to find perf commands, but we prepend some higher
* precedence paths: the "--exec-path" option, the PERF_EXEC_PATH
* environment, and the $(perfexecdir) from the Makefile at build
* time.
*/
setup_path();
/*
* Block SIGWINCH notifications so that the thread that wants it can
* unblock and get syscalls like select interrupted instead of waiting
* forever while the signal goes to some other non interested thread.
*/
pthread__block_sigwinch();
while (1) {
static int done_help;
int was_alias = run_argv(&argc, &argv);
if (errno != ENOENT)
break;
if (was_alias) {
fprintf(stderr, "Expansion of alias '%s' failed; "
"'%s' is not a perf-command\n",
cmd, argv[0]);
goto out;
}
if (!done_help) {
cmd = argv[0] = help_unknown_cmd(cmd);
done_help = 1;
} else
break;
}
fprintf(stderr, "Failed to run command '%s': %s\n",
cmd, strerror(errno));
out:
return 1;
}
int cmd_main(int argc, const char **argv)
{
const char *cmd;
int done_help = 0;
cmd = argv[0];
if (!cmd)
cmd = "git-help";
else {
const char *slash = find_last_dir_sep(cmd);
if (slash)
cmd = slash + 1;
}
/*
* wait_for_pager_atexit will close stdout/stderr so it needs to be
* registered first so that it will execute last and not close the
* handles until all other atexit handlers have finished
*/
atexit(wait_for_pager_atexit);
trace_command_performance(argv);
atexit(post_command_hook_atexit);
/*
* "git-xxxx" is the same as "git xxxx", but we obviously:
*
* - cannot take flags in between the "git" and the "xxxx".
* - cannot execute it externally (since it would just do
* the same thing over again)
*
* So we just directly call the builtin handler, and die if
* that one cannot handle it.
*/
if (skip_prefix(cmd, "git-", &cmd)) {
argv[0] = cmd;
handle_builtin(argc, argv);
die("cannot handle %s as a builtin", cmd);
}
/* Look for flags.. */
argv++;
argc--;
handle_options(&argv, &argc, NULL);
if (argc > 0) {
/* translate --help and --version into commands */
skip_prefix(argv[0], "--", &argv[0]);
} else {
/* The user didn't specify a command; give them help */
commit_pager_choice();
if (run_pre_command_hook(argv))
die("pre-command hook aborted command");
printf("usage: %s\n\n", git_usage_string);
list_common_cmds_help();
printf("\n%s\n", _(git_more_info_string));
exit_code = 1;
run_post_command_hook();
exit(exit_code);
}
cmd = argv[0];
/*
* We use PATH to find git commands, but we prepend some higher
* precedence paths: the "--exec-path" option, the GIT_EXEC_PATH
* environment, and the $(gitexecdir) from the Makefile at build
* time.
*/
setup_path();
while (1) {
int was_alias = run_argv(&argc, &argv);
if (errno != ENOENT)
break;
if (was_alias) {
fprintf(stderr, _("expansion of alias '%s' failed; "
"'%s' is not a git command\n"),
cmd, argv[0]);
exit(1);
}
if (!done_help) {
cmd = argv[0] = help_unknown_cmd(cmd);
done_help = 1;
} else
break;
}
fprintf(stderr, _("failed to run command '%s': %s\n"),
cmd, strerror(errno));
return 1;
}
int cmd_receive_pack(int argc, const char **argv, const char *prefix)
{
int advertise_refs = 0;
int stateless_rpc = 0;
int i;
char *dir = NULL;
struct command *commands;
packet_trace_identity("receive-pack");
argv++;
for (i = 1; i < argc; i++) {
const char *arg = *argv++;
if (*arg == '-') {
if (!strcmp(arg, "--advertise-refs")) {
advertise_refs = 1;
continue;
}
if (!strcmp(arg, "--stateless-rpc")) {
stateless_rpc = 1;
continue;
}
usage(receive_pack_usage);
}
if (dir)
usage(receive_pack_usage);
dir = xstrdup(arg);
}
if (!dir)
usage(receive_pack_usage);
setup_path();
if (!enter_repo(dir, 0))
die("'%s' does not appear to be a git repository", dir);
if (is_repository_shallow())
die("attempt to push into a shallow repository");
git_config(receive_pack_config, NULL);
if (0 <= transfer_unpack_limit)
unpack_limit = transfer_unpack_limit;
else if (0 <= receive_unpack_limit)
unpack_limit = receive_unpack_limit;
if (advertise_refs || !stateless_rpc) {
write_head_info();
}
if (advertise_refs)
return 0;
if ((commands = read_head_info()) != NULL) {
const char *unpack_status = NULL;
if (!delete_only(commands))
unpack_status = unpack();
execute_commands(commands, unpack_status);
if (pack_lockfile)
unlink_or_warn(pack_lockfile);
if (report_status)
report(commands, unpack_status);
run_receive_hook(commands, post_receive_hook, 1);
run_update_post_hook(commands);
if (auto_gc) {
const char *argv_gc_auto[] = {
"gc", "--auto", "--quiet", NULL,
};
run_command_v_opt(argv_gc_auto, RUN_GIT_CMD);
}
if (auto_update_server_info)
update_server_info(0);
}
if (use_sideband)
packet_flush(1);
return 0;
}