BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved)
{
if (reason == DLL_PROCESS_ATTACH)
{
ac3filter_instance = hinst;
// Init NLS
// Search NLS DLL at the filter's folder
size_t path_size = MAX_PATH;
char path[MAX_PATH];
path_size = GetModuleFileName(hinst, path, (DWORD)path_size);
if (path_size)
if (cut_last_name(path, path_size))
init_nls(path);
// Init logging
init_logging();
}
if (reason == DLL_PROCESS_DETACH)
{
uninit_logging();
}
return DllEntryPoint(hinst, reason, reserved);
}
/**************************************************************************
Entry point of the freeciv-modpack program
**************************************************************************/
int main(int argc, char *argv[])
{
GtkWidget *toplevel;
int loglevel = LOG_NORMAL;
int ui_options;
init_nls();
init_character_encodings(FC_DEFAULT_DATA_ENCODING, FALSE);
fc_init_network();
g_thread_init(NULL);
log_init(NULL, loglevel, NULL, NULL, -1);
/* This modifies argv! */
ui_options = fcmp_parse_cmdline(argc, argv);
if (ui_options != -1) {
/* Process GTK arguments */
gtk_init(&ui_options, &argv);
toplevel = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_realize(toplevel);
gtk_widget_set_name(toplevel, "Freeciv-modpack");
gtk_window_set_title(GTK_WINDOW(toplevel), _("Freeciv modpack installer"));
/* Keep the icon of the executable on Windows */
#ifndef WIN32_NATIVE
{
/* Unlike main client, this only works if installed. Ignore any
* errors loading the icon. */
GError *err;
(void) gtk_window_set_icon_from_file(GTK_WINDOW(toplevel), MPICON_PATH,
&err);
}
#endif /* WIN32_NATIVE */
g_signal_connect(toplevel, "delete_event",
G_CALLBACK(quit_dialog_callback), NULL);
modinst_setup_widgets(toplevel);
gtk_widget_show_all(toplevel);
gtk_main();
}
return EXIT_SUCCESS;
}
int main( int argc, char **argv)
{
init_nls();
printf( "%s v%s server - by Ricardo Quesada\n\n", TEG_NAME, VERSION);
dont_run_as_root();
server_init(); /* default values for server */
game_init(); /* default values for the game */
argument_init(argc, argv); /* parse command line */
printf( _("Bound to port: %d\n"),g_server.port );
printf( _("Using seed: %u\n\n"),g_game.seed );
if( g_server.with_console ) {
if( ! g_server.metaserver_on )
printf( _("Type '%s %s' to publish this server in the metaserver\n"),TOKEN_METASERVER, OPTION_META_ON);
printf( _("Type '%s' for more help\n"),TOKEN_HELP);
console_init(); /* initialize console */
} else {
if( !g_server.with_ggz )
printf(_("Standalone server.\n"));
else
printf(_("GGZ mode activated.\n"));
}
srand( g_game.seed );
#ifdef WITH_GGZ
if( g_server.with_ggz )
return ggz_server_main_loop();
else
#endif /* WITH_GGZ */
metaserver_publish();
main_loop();
if( g_server.with_console )
console_quit();
return 1;
}
/*
***************************************************************************
* Main entry to the iostat program.
***************************************************************************
*/
int main(int argc, char **argv)
{
int it = 0;
int opt = 1;
int i, report_set = FALSE;
long count = 1;
struct utsname header;
struct io_dlist *st_dev_list_i;
struct tm rectime;
char *t, *persist_devname, *devname;
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
/* Get HZ */
get_HZ();
/* Allocate structures for device list */
if (argc > 1) {
salloc_dev_list(argc - 1 + count_csvalues(argc, argv));
}
/* Process args... */
while (opt < argc) {
/* -p option used individually. See below for grouped use */
if (!strcmp(argv[opt], "-p")) {
flags |= I_D_PARTITIONS;
if (argv[++opt] &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt])) &&
(strncmp(argv[opt], "-", 1))) {
flags |= I_D_UNFILTERED;
for (t = strtok(argv[opt], ","); t; t = strtok(NULL, ",")) {
if (!strcmp(t, K_ALL)) {
flags |= I_D_PART_ALL;
}
else {
devname = device_name(t);
if (DISPLAY_PERSIST_NAME_I(flags)) {
/* Get device persistent name */
persist_devname = get_pretty_name_from_persistent(devname);
if (persist_devname != NULL) {
devname = persist_devname;
}
}
/* Store device name */
i = update_dev_list(&dlist_idx, devname);
st_dev_list_i = st_dev_list + i;
st_dev_list_i->disp_part = TRUE;
}
}
opt++;
}
else {
flags |= I_D_PART_ALL;
}
}
else if (!strcmp(argv[opt], "-g")) {
/*
* Option -g: Stats for a group of devices.
* group_name contains the last group name entered on
* the command line. If we define an additional one, save
* the previous one in the list. We do that this way because we
* want the group name to appear in the list _after_ all
* the devices included in that group. The last group name
* will be saved in the list later, in presave_device_list() function.
*/
if (group_nr > 0) {
update_dev_list(&dlist_idx, group_name);
}
if (argv[++opt]) {
/*
* MAX_NAME_LEN - 2: one char for the heading space,
* and one for the trailing '\0'.
*/
snprintf(group_name, MAX_NAME_LEN, " %-.*s", MAX_NAME_LEN - 2, argv[opt++]);
}
else {
usage(argv[0]);
}
group_nr++;
}
else if (!strcmp(argv[opt], "-j")) {
if (argv[++opt]) {
if (strnlen(argv[opt], MAX_FILE_LEN) >= MAX_FILE_LEN - 1) {
usage(argv[0]);
}
strncpy(persistent_name_type, argv[opt], MAX_FILE_LEN - 1);
persistent_name_type[MAX_FILE_LEN - 1] = '\0';
strtolower(persistent_name_type);
/* Check that this is a valid type of persistent device name */
if (!get_persistent_type_dir(persistent_name_type)) {
fprintf(stderr, _("Invalid type of persistent device name\n"));
exit(1);
}
/*
* Persistent names are usually long: Display
* them as human readable by default.
*/
flags |= I_D_PERSIST_NAME + I_D_HUMAN_READ;
opt++;
}
else {
usage(argv[0]);
}
}
#ifdef DEBUG
else if (!strcmp(argv[opt], "--debuginfo")) {
flags |= I_D_DEBUG;
opt++;
}
#endif
else if (!strncmp(argv[opt], "-", 1)) {
for (i = 1; *(argv[opt] + i); i++) {
switch (*(argv[opt] + i)) {
case 'c':
/* Display cpu usage */
flags |= I_D_CPU;
report_set = TRUE;
break;
case 'd':
/* Display disk utilization */
flags |= I_D_DISK;
report_set = TRUE;
break;
case 'h':
/*
* Display device utilization report
* in a human readable format.
*/
flags |= I_D_HUMAN_READ;
break;
case 'k':
if (DISPLAY_MEGABYTES(flags)) {
usage(argv[0]);
}
/* Display stats in kB/s */
flags |= I_D_KILOBYTES;
break;
case 'm':
if (DISPLAY_KILOBYTES(flags)) {
usage(argv[0]);
}
/* Display stats in MB/s */
flags |= I_D_MEGABYTES;
break;
case 'N':
/* Display device mapper logical name */
flags |= I_D_DEVMAP_NAME;
break;
case 'p':
/* If option -p is grouped then it cannot take an arg */
flags |= I_D_PARTITIONS + I_D_PART_ALL;
break;
case 'T':
/* Display stats only for the groups */
flags |= I_D_GROUP_TOTAL_ONLY;
break;
case 't':
/* Display timestamp */
flags |= I_D_TIMESTAMP;
break;
case 'x':
/* Display extended stats */
flags |= I_D_EXTENDED;
break;
case 'y':
/* Don't display stats since system restart */
flags |= I_D_OMIT_SINCE_BOOT;
break;
case 'z':
/* Omit output for devices with no activity */
flags |= I_D_ZERO_OMIT;
break;
case 'V':
/* Print version number and exit */
print_version();
break;
default:
usage(argv[0]);
}
}
opt++;
}
else if (!isdigit(argv[opt][0])) {
/*
* By default iostat doesn't display unused devices.
* If some devices are explictly entered on the command line
* then don't apply this rule any more.
*/
flags |= I_D_UNFILTERED;
if (strcmp(argv[opt], K_ALL)) {
/* Store device name entered on the command line */
devname = device_name(argv[opt++]);
if (DISPLAY_PERSIST_NAME_I(flags)) {
persist_devname = get_pretty_name_from_persistent(devname);
if (persist_devname != NULL) {
devname = persist_devname;
}
}
update_dev_list(&dlist_idx, devname);
}
else {
opt++;
}
}
else if (!it) {
interval = atol(argv[opt++]);
if (interval < 0) {
usage(argv[0]);
}
count = -1;
it = 1;
}
else if (it > 0) {
count = atol(argv[opt++]);
if ((count < 1) || !interval) {
usage(argv[0]);
}
it = -1;
}
else {
usage(argv[0]);
}
}
if (!interval) {
count = 1;
}
/* Default: Display CPU and DISK reports */
if (!report_set) {
flags |= I_D_CPU + I_D_DISK;
}
/*
* Also display DISK reports if options -p, -x or a device has been entered
* on the command line.
*/
if (DISPLAY_PARTITIONS(flags) || DISPLAY_EXTENDED(flags) ||
DISPLAY_UNFILTERED(flags)) {
flags |= I_D_DISK;
}
/* Option -T can only be used with option -g */
if (DISPLAY_GROUP_TOTAL_ONLY(flags) && !group_nr) {
usage(argv[0]);
}
/* Select disk output unit (kB/s or blocks/s) */
set_disk_output_unit();
/* Ignore device list if '-p ALL' entered on the command line */
if (DISPLAY_PART_ALL(flags)) {
dlist_idx = 0;
}
if (DISPLAY_DEVMAP_NAME(flags)) {
dm_major = get_devmap_major();
}
/* Init structures according to machine architecture */
io_sys_init();
if (group_nr > 0) {
/*
* If groups of devices have been defined
* then save devices and groups in the list.
*/
presave_device_list();
}
get_localtime(&rectime, 0);
/* Get system name, release number and hostname */
uname(&header);
if (print_gal_header(&rectime, header.sysname, header.release,
header.nodename, header.machine, cpu_nr)) {
flags |= I_D_ISO;
}
printf("\n");
/* Set a handler for SIGALRM */
memset(&alrm_act, 0, sizeof(alrm_act));
alrm_act.sa_handler = alarm_handler;
sigaction(SIGALRM, &alrm_act, NULL);
alarm(interval);
/* Main loop */
rw_io_stat_loop(count, &rectime);
/* Free structures */
io_sys_free();
sfree_dev_list();
return 0;
}
/*
***************************************************************************
* Main entry to the cifsiostat program.
***************************************************************************
*/
int main(int argc, char **argv)
{
int it = 0;
int opt = 1;
int i;
long count = 1;
struct utsname header;
struct tm rectime;
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
/* Get HZ */
get_HZ();
/* Process args... */
while (opt < argc) {
#ifdef DEBUG
if (!strcmp(argv[opt], "--debuginfo")) {
flags |= I_D_DEBUG;
opt++;
} else
#endif
if (!strncmp(argv[opt], "-", 1)) {
for (i = 1; *(argv[opt] + i); i++) {
switch (*(argv[opt] + i)) {
case 'h':
/* Display an easy-to-read CIFS report */
flags |= I_D_HUMAN_READ;
break;
case 'k':
if (DISPLAY_MEGABYTES(flags)) {
usage(argv[0]);
}
/* Display stats in kB/s */
flags |= I_D_KILOBYTES;
break;
case 'm':
if (DISPLAY_KILOBYTES(flags)) {
usage(argv[0]);
}
/* Display stats in MB/s */
flags |= I_D_MEGABYTES;
break;
case 't':
/* Display timestamp */
flags |= I_D_TIMESTAMP;
break;
case 'V':
/* Print version number and exit */
print_version();
break;
default:
usage(argv[0]);
}
}
opt++;
}
else if (!it) {
interval = atol(argv[opt++]);
if (interval < 0) {
usage(argv[0]);
}
count = -1;
it = 1;
}
else if (it > 0) {
count = atol(argv[opt++]);
if ((count < 1) || !interval) {
usage(argv[0]);
}
it = -1;
}
else {
usage(argv[0]);
}
}
if (!interval) {
count = 1;
}
/* Init structures according to machine architecture */
io_sys_init();
get_localtime(&rectime);
/* Get system name, release number and hostname */
uname(&header);
if (print_gal_header(&rectime, header.sysname, header.release,
header.nodename, header.machine, cpu_nr)) {
flags |= I_D_ISO;
}
printf("\n");
/* Set a handler for SIGALRM */
alarm_handler(0);
/* Main loop */
rw_io_stat_loop(count, &rectime);
/* Free structures */
io_sys_free();
return 0;
}
/* process HTTP or SSDP requests */
int
main(int argc, char **argv)
{
int ret, i;
int shttpl = -1;
int smonitor = -1;
LIST_HEAD(httplisthead, upnphttp) upnphttphead;
struct upnphttp * e = 0;
struct upnphttp * next;
fd_set readset; /* for select() */
fd_set writeset;
struct timeval timeout, timeofday, lastnotifytime = {0, 0};
time_t lastupdatetime = 0;
int max_fd = -1;
int last_changecnt = 0;
pid_t scanner_pid = 0;
pthread_t inotify_thread = 0;
#ifdef TIVO_SUPPORT
uint8_t beacon_interval = 5;
int sbeacon = -1;
struct sockaddr_in tivo_bcast;
struct timeval lastbeacontime = {0, 0};
#endif
for (i = 0; i < L_MAX; i++)
log_level[i] = E_WARN;
init_nls();
ret = init(argc, argv);
if (ret != 0)
return 1;
#if (!defined(RTN66U) && !defined(RTN56U))
init_icon(PATH_ICON_PNG_SM);
init_icon(PATH_ICON_PNG_LRG);
init_icon(PATH_ICON_JPEG_SM);
init_icon(PATH_ICON_JPEG_LRG);
#endif
DPRINTF(E_WARN, L_GENERAL, "Starting " SERVER_NAME " version " MINIDLNA_VERSION ".\n");
if (sqlite3_libversion_number() < 3005001)
{
DPRINTF(E_WARN, L_GENERAL, "SQLite library is old. Please use version 3.5.1 or newer.\n");
}
LIST_INIT(&upnphttphead);
ret = open_db(NULL);
if (ret == 0)
{
updateID = sql_get_int_field(db, "SELECT VALUE from SETTINGS where KEY = 'UPDATE_ID'");
if (updateID == -1)
ret = -1;
}
check_db(db, ret, &scanner_pid);
#ifdef HAVE_INOTIFY
if( GETFLAG(INOTIFY_MASK) )
{
if (!sqlite3_threadsafe() || sqlite3_libversion_number() < 3005001)
DPRINTF(E_ERROR, L_GENERAL, "SQLite library is not threadsafe! "
"Inotify will be disabled.\n");
else if (pthread_create(&inotify_thread, NULL, start_inotify, NULL) != 0)
DPRINTF(E_FATAL, L_GENERAL, "ERROR: pthread_create() failed for start_inotify. EXITING\n");
}
#endif
smonitor = OpenAndConfMonitorSocket();
sssdp = OpenAndConfSSDPReceiveSocket();
if (sssdp < 0)
{
DPRINTF(E_INFO, L_GENERAL, "Failed to open socket for receiving SSDP. Trying to use MiniSSDPd\n");
if (SubmitServicesToMiniSSDPD(lan_addr[0].str, runtime_vars.port) < 0)
DPRINTF(E_FATAL, L_GENERAL, "Failed to connect to MiniSSDPd. EXITING");
}
/* open socket for HTTP connections. */
shttpl = OpenAndConfHTTPSocket(runtime_vars.port);
if (shttpl < 0)
DPRINTF(E_FATAL, L_GENERAL, "Failed to open socket for HTTP. EXITING\n");
DPRINTF(E_WARN, L_GENERAL, "HTTP listening on port %d\n", runtime_vars.port);
#ifdef TIVO_SUPPORT
if (GETFLAG(TIVO_MASK))
{
DPRINTF(E_WARN, L_GENERAL, "TiVo support is enabled.\n");
/* Add TiVo-specific randomize function to sqlite */
ret = sqlite3_create_function(db, "tivorandom", 1, SQLITE_UTF8, NULL, &TiVoRandomSeedFunc, NULL, NULL);
if (ret != SQLITE_OK)
DPRINTF(E_ERROR, L_TIVO, "ERROR: Failed to add sqlite randomize function for TiVo!\n");
/* open socket for sending Tivo notifications */
sbeacon = OpenAndConfTivoBeaconSocket();
if(sbeacon < 0)
DPRINTF(E_FATAL, L_GENERAL, "Failed to open sockets for sending Tivo beacon notify "
"messages. EXITING\n");
tivo_bcast.sin_family = AF_INET;
tivo_bcast.sin_addr.s_addr = htonl(getBcastAddress());
tivo_bcast.sin_port = htons(2190);
}
#endif
reload_ifaces(0);
lastnotifytime.tv_sec = time(NULL) + runtime_vars.notify_interval;
/* main loop */
while (!quitting)
{
/* Check if we need to send SSDP NOTIFY messages and do it if
* needed */
if (gettimeofday(&timeofday, 0) < 0)
{
DPRINTF(E_ERROR, L_GENERAL, "gettimeofday(): %s\n", strerror(errno));
timeout.tv_sec = runtime_vars.notify_interval;
timeout.tv_usec = 0;
}
else
{
/* the comparison is not very precise but who cares ? */
if (timeofday.tv_sec >= (lastnotifytime.tv_sec + runtime_vars.notify_interval))
{
DPRINTF(E_DEBUG, L_SSDP, "Sending SSDP notifies\n");
for (i = 0; i < n_lan_addr; i++)
{
SendSSDPNotifies(lan_addr[i].snotify, lan_addr[i].str,
runtime_vars.port, runtime_vars.notify_interval);
}
memcpy(&lastnotifytime, &timeofday, sizeof(struct timeval));
timeout.tv_sec = runtime_vars.notify_interval;
timeout.tv_usec = 0;
}
else
{
timeout.tv_sec = lastnotifytime.tv_sec + runtime_vars.notify_interval
- timeofday.tv_sec;
if (timeofday.tv_usec > lastnotifytime.tv_usec)
{
timeout.tv_usec = 1000000 + lastnotifytime.tv_usec
- timeofday.tv_usec;
timeout.tv_sec--;
}
else
timeout.tv_usec = lastnotifytime.tv_usec - timeofday.tv_usec;
}
#ifdef TIVO_SUPPORT
if (sbeacon >= 0)
{
if (timeofday.tv_sec >= (lastbeacontime.tv_sec + beacon_interval))
{
sendBeaconMessage(sbeacon, &tivo_bcast, sizeof(struct sockaddr_in), 1);
memcpy(&lastbeacontime, &timeofday, sizeof(struct timeval));
if (timeout.tv_sec > beacon_interval)
{
timeout.tv_sec = beacon_interval;
timeout.tv_usec = 0;
}
/* Beacons should be sent every 5 seconds or so for the first minute,
* then every minute or so thereafter. */
if (beacon_interval == 5 && (timeofday.tv_sec - startup_time) > 60)
beacon_interval = 60;
}
else if (timeout.tv_sec > (lastbeacontime.tv_sec + beacon_interval + 1 - timeofday.tv_sec))
timeout.tv_sec = lastbeacontime.tv_sec + beacon_interval - timeofday.tv_sec;
}
#endif
}
if (scanning)
{
if (!scanner_pid || kill(scanner_pid, 0) != 0)
{
scanning = 0;
updateID++;
}
}
/* select open sockets (SSDP, HTTP listen, and all HTTP soap sockets) */
FD_ZERO(&readset);
if (sssdp >= 0)
{
FD_SET(sssdp, &readset);
max_fd = MAX(max_fd, sssdp);
}
if (shttpl >= 0)
{
FD_SET(shttpl, &readset);
max_fd = MAX(max_fd, shttpl);
}
#ifdef TIVO_SUPPORT
if (sbeacon >= 0)
{
FD_SET(sbeacon, &readset);
max_fd = MAX(max_fd, sbeacon);
}
#endif
if (smonitor >= 0)
{
FD_SET(smonitor, &readset);
max_fd = MAX(max_fd, smonitor);
}
i = 0; /* active HTTP connections count */
for (e = upnphttphead.lh_first; e != NULL; e = e->entries.le_next)
{
if ((e->socket >= 0) && (e->state <= 2))
{
FD_SET(e->socket, &readset);
max_fd = MAX(max_fd, e->socket);
i++;
}
}
FD_ZERO(&writeset);
upnpevents_selectfds(&readset, &writeset, &max_fd);
ret = select(max_fd+1, &readset, &writeset, 0, &timeout);
if (ret < 0)
{
if(quitting) goto shutdown;
if(errno == EINTR) continue;
DPRINTF(E_ERROR, L_GENERAL, "select(all): %s\n", strerror(errno));
DPRINTF(E_FATAL, L_GENERAL, "Failed to select open sockets. EXITING\n");
}
upnpevents_processfds(&readset, &writeset);
/* process SSDP packets */
if (sssdp >= 0 && FD_ISSET(sssdp, &readset))
{
/*DPRINTF(E_DEBUG, L_GENERAL, "Received SSDP Packet\n");*/
ProcessSSDPRequest(sssdp, (unsigned short)runtime_vars.port);
}
#ifdef TIVO_SUPPORT
if (sbeacon >= 0 && FD_ISSET(sbeacon, &readset))
{
/*DPRINTF(E_DEBUG, L_GENERAL, "Received UDP Packet\n");*/
ProcessTiVoBeacon(sbeacon);
}
#endif
if (smonitor >= 0 && FD_ISSET(smonitor, &readset))
{
ProcessMonitorEvent(smonitor);
}
/* increment SystemUpdateID if the content database has changed,
* and if there is an active HTTP connection, at most once every 2 seconds */
if (i && (timeofday.tv_sec >= (lastupdatetime + 2)))
{
if (scanning || sqlite3_total_changes(db) != last_changecnt)
{
updateID++;
last_changecnt = sqlite3_total_changes(db);
upnp_event_var_change_notify(EContentDirectory);
lastupdatetime = timeofday.tv_sec;
}
}
/* process active HTTP connections */
for (e = upnphttphead.lh_first; e != NULL; e = e->entries.le_next)
{
if ((e->socket >= 0) && (e->state <= 2) && (FD_ISSET(e->socket, &readset)))
Process_upnphttp(e);
}
/* process incoming HTTP connections */
if (shttpl >= 0 && FD_ISSET(shttpl, &readset))
{
int shttp;
socklen_t clientnamelen;
struct sockaddr_in clientname;
clientnamelen = sizeof(struct sockaddr_in);
shttp = accept(shttpl, (struct sockaddr *)&clientname, &clientnamelen);
if (shttp<0)
{
DPRINTF(E_ERROR, L_GENERAL, "accept(http): %s\n", strerror(errno));
}
else
{
struct upnphttp * tmp = 0;
DPRINTF(E_DEBUG, L_GENERAL, "HTTP connection from %s:%d\n",
inet_ntoa(clientname.sin_addr),
ntohs(clientname.sin_port) );
/*if (fcntl(shttp, F_SETFL, O_NONBLOCK) < 0) {
DPRINTF(E_ERROR, L_GENERAL, "fcntl F_SETFL, O_NONBLOCK\n");
}*/
/* Create a new upnphttp object and add it to
* the active upnphttp object list */
tmp = New_upnphttp(shttp);
if (tmp)
{
tmp->clientaddr = clientname.sin_addr;
LIST_INSERT_HEAD(&upnphttphead, tmp, entries);
}
else
{
DPRINTF(E_ERROR, L_GENERAL, "New_upnphttp() failed\n");
close(shttp);
}
}
}
/* delete finished HTTP connections */
for (e = upnphttphead.lh_first; e != NULL; e = next)
{
next = e->entries.le_next;
if(e->state >= 100)
{
LIST_REMOVE(e, entries);
Delete_upnphttp(e);
}
}
}
shutdown:
/* kill the scanner */
if (scanning && scanner_pid)
kill(scanner_pid, SIGKILL);
/* kill other child processes */
process_reap_children();
free(children);
/* close out open sockets */
while (upnphttphead.lh_first != NULL)
{
e = upnphttphead.lh_first;
LIST_REMOVE(e, entries);
Delete_upnphttp(e);
}
if (sssdp >= 0)
close(sssdp);
if (shttpl >= 0)
close(shttpl);
#ifdef TIVO_SUPPORT
if (sbeacon >= 0)
close(sbeacon);
#endif
for (i = 0; i < n_lan_addr; i++)
{
SendSSDPGoodbyes(lan_addr[i].snotify);
close(lan_addr[i].snotify);
}
if (inotify_thread)
pthread_join(inotify_thread, NULL);
sql_exec(db, "UPDATE SETTINGS set VALUE = '%u' where KEY = 'UPDATE_ID'", updateID);
sqlite3_close(db);
upnpevents_removeSubscribers();
if (pidfilename && unlink(pidfilename) < 0)
DPRINTF(E_ERROR, L_GENERAL, "Failed to remove pidfile %s: %s\n", pidfilename, strerror(errno));
log_close();
freeoptions();
exit(EXIT_SUCCESS);
}
/*
***************************************************************************
* Main entry to the sar program.
***************************************************************************
*/
int main(int argc, char **argv)
{
int i, rc, opt = 1, args_idx = 2;
int fd[2];
int day_offset = 0;
char from_file[MAX_FILE_LEN], to_file[MAX_FILE_LEN];
char ltemp[20];
/* Get HZ */
get_HZ();
/* Compute page shift in kB */
get_kb_shift();
from_file[0] = to_file[0] = '\0';
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
tm_start.use = tm_end.use = FALSE;
/* Allocate and init activity bitmaps */
allocate_bitmaps(act);
init_structures();
/* Process options */
while (opt < argc) {
if (!strcmp(argv[opt], "-I")) {
if (argv[++opt]) {
/* Parse -I option */
if (parse_sar_I_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-D")) {
/* Option to tell sar to write to saYYYYMMDD data files */
flags |= S_F_SA_YYYYMMDD;
opt++;
}
else if (!strcmp(argv[opt], "-P")) {
/* Parse -P option */
if (parse_sa_P_opt(argv, &opt, &flags, act)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-o")) {
if (to_file[0]) {
/* Output file already specified */
usage(argv[0]);
}
/* Save stats to a file */
if ((argv[++opt]) && strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
strncpy(to_file, argv[opt++], MAX_FILE_LEN);
to_file[MAX_FILE_LEN - 1] = '\0';
}
else {
strcpy(to_file, "-");
}
}
else if (!strcmp(argv[opt], "-f")) {
if (from_file[0]) {
/* Input file already specified */
usage(argv[0]);
}
/* Read stats from a file */
if ((argv[++opt]) && strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
strncpy(from_file, argv[opt++], MAX_FILE_LEN);
from_file[MAX_FILE_LEN - 1] = '\0';
/* Check if this is an alternate directory for sa files */
check_alt_sa_dir(from_file, day_offset, -1);
}
else {
set_default_file(from_file, day_offset, -1);
}
}
else if (!strcmp(argv[opt], "-s")) {
/* Get time start */
if (parse_timestamp(argv, &opt, &tm_start, DEF_TMSTART)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-e")) {
/* Get time end */
if (parse_timestamp(argv, &opt, &tm_end, DEF_TMEND)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-h")) {
/* Display help message */
display_help(argv[0]);
}
else if (!strcmp(argv[opt], "-i")) {
if (!argv[++opt] || (strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval < 1) {
usage(argv[0]);
}
flags |= S_F_INTERVAL_SET;
}
else if (!strcmp(argv[opt], "-m")) {
if (argv[++opt]) {
/* Parse option -m */
if (parse_sar_m_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-n")) {
if (argv[++opt]) {
/* Parse option -n */
if (parse_sar_n_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if ((strlen(argv[opt]) > 1) &&
(strlen(argv[opt]) < 4) &&
!strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt] + 1, DIGITS) == (strlen(argv[opt]) - 1))) {
day_offset = atoi(argv[opt++] + 1);
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Other options not previously tested */
if ((rc = parse_sar_opt(argv, &opt, act, &flags, C_SAR)) != 0) {
if (rc == 1) {
usage(argv[0]);
}
exit(1);
}
opt++;
}
else if (interval < 0) {
/* Get interval */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval < 0) {
usage(argv[0]);
}
}
else {
/* Get count value */
if ((strspn(argv[opt], DIGITS) != strlen(argv[opt])) ||
!interval) {
usage(argv[0]);
}
if (count) {
/* Count parameter already set */
usage(argv[0]);
}
count = atol(argv[opt++]);
if (count < 1) {
usage(argv[0]);
}
}
}
/* 'sar' is equivalent to 'sar -f' */
if ((argc == 1) ||
((interval < 0) && !from_file[0] && !to_file[0])) {
set_default_file(from_file, day_offset, -1);
}
if (tm_start.use && tm_end.use && (tm_end.tm_hour < tm_start.tm_hour)) {
tm_end.tm_hour += 24;
}
/*
* Check option dependencies.
*/
/* You read from a file OR you write to it... */
if (from_file[0] && to_file[0]) {
fprintf(stderr, _("-f and -o options are mutually exclusive\n"));
exit(1);
}
/* Use time start or option -i only when reading stats from a file */
if ((tm_start.use || INTERVAL_SET(flags)) && !from_file[0]) {
fprintf(stderr,
_("Not reading from a system activity file (use -f option)\n"));
exit(1);
}
/* Don't print stats since boot time if -o or -f options are used */
if (!interval && (from_file[0] || to_file[0])) {
usage(argv[0]);
}
/* Cannot enter a day shift with -o option */
if (to_file[0] && day_offset) {
usage(argv[0]);
}
if (USE_PRETTY_OPTION(flags)) {
dm_major = get_devmap_major();
}
if (!count) {
/*
* count parameter not set: Display all the contents of the file
* or generate a report continuously.
*/
count = -1;
}
/* Default is CPU activity... */
select_default_activity(act);
/* Reading stats from file: */
if (from_file[0]) {
if (interval < 0) {
interval = 1;
}
/* Read stats from file */
read_stats_from_file(from_file);
/* Free stuctures and activity bitmaps */
free_bitmaps(act);
free_structures(act);
return 0;
}
/* Reading stats from sadc: */
/* Create anonymous pipe */
if (pipe(fd) == -1) {
perror("pipe");
exit(4);
}
switch (fork()) {
case -1:
perror("fork");
exit(4);
break;
case 0: /* Child */
if (dup2(fd[1], STDOUT_FILENO) < 0) {
perror("dup2");
exit(4);
}
CLOSE_ALL(fd);
/*
* Prepare options for sadc.
*/
/* Program name */
salloc(0, SADC);
/* Interval value */
if (interval < 0) {
usage(argv[0]);
}
else if (!interval) {
strcpy(ltemp, "1");
}
else {
sprintf(ltemp, "%ld", interval);
}
salloc(1, ltemp);
/* Count number */
if (count >= 0) {
sprintf(ltemp, "%ld", count + 1);
salloc(args_idx++, ltemp);
}
/* Flags to be passed to sadc */
salloc(args_idx++, "-z");
/* Writing data to a file (option -o) */
if (to_file[0]) {
/* Set option -D if entered */
if (USE_SA_YYYYMMDD(flags)) {
salloc(args_idx++, "-D");
}
/* Collect all possible activities (option -S XALL for sadc) */
salloc(args_idx++, "-S");
salloc(args_idx++, K_XALL);
/* Outfile arg */
salloc(args_idx++, to_file);
}
else {
/*
* If option -o hasn't been used, then tell sadc
* to collect only activities that will be displayed.
*/
int act_id = 0;
for (i = 0; i < NR_ACT; i++) {
if (IS_SELECTED(act[i]->options)) {
act_id |= act[i]->group;
}
}
if (act_id) {
act_id <<= 8;
snprintf(ltemp, 19, "%d", act_id);
ltemp[19] = '\0';
salloc(args_idx++, "-S");
salloc(args_idx++, ltemp);
}
}
/* Last arg is NULL */
args[args_idx] = NULL;
/* Call now the data collector */
execv(SADC_PATH, args);
execvp(SADC, args);
/*
* Note: Don't use execl/execlp since we don't have a fixed number of
* args to give to sadc.
*/
fprintf(stderr, _("Cannot find the data collector (%s)\n"), SADC);
perror("exec");
exit(4);
break;
default: /* Parent */
if (dup2(fd[0], STDIN_FILENO) < 0) {
perror("dup2");
exit(4);
}
CLOSE_ALL(fd);
/* Get now the statistics */
read_stats();
break;
}
/* Free structures and activity bitmaps */
free_bitmaps(act);
free_structures(act);
return 0;
}
/*
***************************************************************************
* Main entry to the sar program
***************************************************************************
*/
int main(int argc, char **argv)
{
int opt = 1, args_idx = 2;
int fd[2];
char from_file[MAX_FILE_LEN], to_file[MAX_FILE_LEN];
char ltemp[20];
/* Get HZ */
get_HZ();
/* Compute page shift in kB */
get_kb_shift();
from_file[0] = to_file[0] = '\0';
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
tm_start.use = tm_end.use = FALSE;
/* Allocate and init activity bitmaps */
allocate_bitmaps(act);
init_structures();
/* Process options */
while (opt < argc) {
if (!strcmp(argv[opt], "-I")) {
if (argv[++opt]) {
/* Parse -I option */
if (parse_sar_I_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-P")) {
/* Parse -P option */
if (parse_sa_P_opt(argv, &opt, &flags, act)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-o")) {
/* Save stats to a file */
if ((argv[++opt]) && strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
strncpy(to_file, argv[opt++], MAX_FILE_LEN);
to_file[MAX_FILE_LEN - 1] = '\0';
}
else {
strcpy(to_file, "-");
}
}
else if (!strcmp(argv[opt], "-f")) {
/* Read stats from a file */
if ((argv[++opt]) && strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
strncpy(from_file, argv[opt++], MAX_FILE_LEN);
from_file[MAX_FILE_LEN - 1] = '\0';
}
else {
set_default_file(&rectime, from_file);
}
}
else if (!strcmp(argv[opt], "-s")) {
/* Get time start */
if (parse_timestamp(argv, &opt, &tm_start, DEF_TMSTART)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-e")) {
/* Get time end */
if (parse_timestamp(argv, &opt, &tm_end, DEF_TMEND)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-i")) {
if (!argv[++opt] || (strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval < 1) {
usage(argv[0]);
}
flags |= S_F_INTERVAL_SET;
}
else if (!strcmp(argv[opt], "-n")) {
if (argv[++opt]) {
/* Parse option -n */
if (parse_sar_n_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Other options not previously tested */
if (parse_sar_opt(argv, &opt, act, &flags, C_SAR)) {
usage(argv[0]);
}
opt++;
}
else if (interval < 0) {
/* Get interval */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval < 0) {
usage(argv[0]);
}
}
else {
/* Get count value */
if ((strspn(argv[opt], DIGITS) != strlen(argv[opt])) ||
!interval) {
usage(argv[0]);
}
if (count) {
/* Count parameter already set */
usage(argv[0]);
}
count = atol(argv[opt++]);
if (count < 1) {
usage(argv[0]);
}
}
}
/* 'sar' is equivalent to 'sar -f' */
if ((argc == 1) ||
((interval < 0) && !from_file[0] && !to_file[0])) {
set_default_file(&rectime, from_file);
}
if (tm_start.use && tm_end.use && (tm_end.tm_hour < tm_start.tm_hour)) {
tm_end.tm_hour += 24;
}
/*
* Check option dependencies
*/
/* You read from a file OR you write to it... */
if (from_file[0] && to_file[0]) {
fprintf(stderr, _("-f and -o options are mutually exclusive\n"));
exit(1);
}
/* Use time start or option -i only when reading stats from a file */
if ((tm_start.use || INTERVAL_SET(flags)) && !from_file[0]) {
fprintf(stderr,
_("Not reading from a system activity file (use -f option)\n"));
exit(1);
}
/* Don't print stats since boot time if -o or -f options are used */
if (!interval && (from_file[0] || to_file[0])) {
usage(argv[0]);
}
if (!count) {
/*
* count parameter not set: Display all the contents of the file
* or generate a report continuously.
*/
count = -1;
}
/* Default is CPU activity... */
select_default_activity(act);
/* ---Reading stats from file */
if (from_file[0]) {
if (interval < 0) {
interval = 1;
}
/* Read stats from file */
read_stats_from_file(from_file);
return 0;
}
/* ---Reading stats from sadc */
/* Create anonymous pipe */
if (pipe(fd) == -1) {
perror("pipe");
exit(4);
}
switch (fork()) {
case -1:
perror("fork");
exit(4);
break;
case 0: /* Child */
if (dup2(fd[1], STDOUT_FILENO) < 0) {
perror("dup2");
exit(4);
}
CLOSE_ALL(fd);
/*
* Prepare options for sadc
*/
/* Program name */
salloc(0, SADC);
/* Interval value */
if (interval < 0) {
usage(argv[0]);
}
else if (!interval) {
strcpy(ltemp, "1");
}
else {
sprintf(ltemp, "%ld", interval);
}
salloc(1, ltemp);
/* Count number */
if (count >= 0) {
sprintf(ltemp, "%ld", count + 1);
salloc(args_idx++, ltemp);
}
/* Flags to be passed to sadc */
salloc(args_idx++, "-z");
salloc(args_idx++, "-S");
salloc(args_idx++, K_ALL);
/* Outfile arg */
if (to_file[0]) {
salloc(args_idx++, to_file);
}
/* Last arg is NULL */
args[args_idx] = NULL;
/* Call now the data collector */
execv(SADC_PATH, args);
execvp(SADC, args);
/*
* Note: don't use execl/execlp since we don't have a fixed number of
* args to give to sadc.
*/
fprintf(stderr, _("Cannot find the data collector (%s)\n"), SADC);
perror("exec");
exit(4);
break;
default: /* Parent */
if (dup2(fd[0], STDIN_FILENO) < 0) {
perror("dup2");
exit(4);
}
CLOSE_ALL(fd);
/* Get now the statistics */
read_stats();
break;
}
return 0;
}
int
main(int argc, char *argv[])
{
static struct option long_options[] = {
{"host", required_argument, NULL, 'h'},
{"port", required_argument, NULL, 'p'},
{"username", required_argument, NULL, 'U'},
{"password", no_argument, NULL, 'W'},
{"echo", no_argument, NULL, 'e'},
{"quiet", no_argument, NULL, 'q'},
{"interactive", no_argument, NULL, 'i'},
{NULL, 0, NULL, 0}
};
char *progname;
int optindex;
int c;
char *dbname = NULL;
char *host = NULL;
char *port = NULL;
char *username = NULL;
bool password = false;
bool echo = false;
bool quiet = false;
bool interactive = false;
PQExpBufferData sql;
PGconn *conn;
PGresult *result;
progname = get_progname(argv[0]);
init_nls();
handle_help_version_opts(argc, argv, "dropdb", help);
while ((c = getopt_long(argc, argv, "h:p:U:Weqi", long_options, &optindex)) != -1)
{
switch (c)
{
case 'h':
host = optarg;
break;
case 'p':
port = optarg;
break;
case 'U':
username = optarg;
break;
case 'W':
password = true;
break;
case 'e':
echo = true;
break;
case 'q':
quiet = true;
break;
case 'i':
interactive = true;
break;
default:
fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
exit(1);
}
}
switch (argc - optind)
{
case 0:
fprintf(stderr, _("%s: missing required argument database name\n"), progname);
fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
exit(1);
case 1:
dbname = argv[optind];
break;
default:
fprintf(stderr, _("%s: too many command-line arguments (first is \"%s\")\n"),
progname, argv[optind + 1]);
fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
exit(1);
}
if (interactive)
{
char *reply;
printf(_("Database \"%s\" will be permanently removed.\n"), dbname);
reply = simple_prompt("Are you sure? (y/n) ", 1, true);
if (check_yesno_response(reply) != 1)
exit(0);
}
initPQExpBuffer(&sql);
appendPQExpBuffer(&sql, "DROP DATABASE %s;\n",
fmtId(dbname));
conn = connectDatabase("template1", host, port, username, password, progname);
if (echo)
printf("%s", sql.data);
result = PQexec(conn, sql.data);
if (PQresultStatus(result) != PGRES_COMMAND_OK)
{
fprintf(stderr, _("%s: database removal failed: %s"),
progname, PQerrorMessage(conn));
PQfinish(conn);
exit(1);
}
PQfinish(conn);
if (!quiet)
{
puts("DROP DATABASE");
fflush(stdout);
}
exit(0);
}
/*
***************************************************************************
* Main entry to the sadf program
***************************************************************************
*/
int main(int argc, char **argv)
{
int opt = 1, sar_options = 0;
int i;
char dfile[MAX_FILE_LEN];
struct tm rectime;
/* Get HZ */
get_HZ();
/* Compute page shift in kB */
get_kb_shift();
dfile[0] = '\0';
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
tm_start.use = tm_end.use = FALSE;
/* Allocate and init activity bitmaps */
allocate_bitmaps(act);
/* Init some structures */
init_structures();
/* Process options */
while (opt < argc) {
if (!strcmp(argv[opt], "-I")) {
if (argv[++opt] && sar_options) {
if (parse_sar_I_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-P")) {
if (parse_sa_P_opt(argv, &opt, &flags, act)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-s")) {
/* Get time start */
if (parse_timestamp(argv, &opt, &tm_start, DEF_TMSTART)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-e")) {
/* Get time end */
if (parse_timestamp(argv, &opt, &tm_end, DEF_TMEND)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "--")) {
sar_options = 1;
opt++;
}
else if (!strcmp(argv[opt], "-m")) {
if (argv[++opt] && sar_options) {
/* Parse sar's option -m */
if (parse_sar_m_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-n")) {
if (argv[++opt] && sar_options) {
/* Parse sar's option -n */
if (parse_sar_n_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Other options not previously tested */
if (sar_options) {
if (parse_sar_opt(argv, &opt, act, &flags, C_SADF)) {
usage(argv[0]);
}
}
else {
for (i = 1; *(argv[opt] + i); i++) {
switch (*(argv[opt] + i)) {
case 'C':
flags |= S_F_COMMENT;
break;
case 'd':
if (format) {
usage(argv[0]);
}
format = F_DB_OUTPUT;
break;
case 'h':
flags |= S_F_HORIZONTALLY;
break;
case 'H':
flags |= S_F_HDR_ONLY;
break;
case 'j':
if (format) {
usage(argv[0]);
}
format = F_JSON_OUTPUT;
break;
case 'p':
if (format) {
usage(argv[0]);
}
format = F_PPC_OUTPUT;
break;
case 't':
flags |= S_F_TRUE_TIME;
break;
case 'T':
flags |= S_F_SEC_EPOCH;
break;
case 'x':
if (format) {
usage(argv[0]);
}
format = F_XML_OUTPUT;
break;
case 'V':
print_version();
break;
default:
usage(argv[0]);
}
}
}
opt++;
}
/* Get data file name */
else if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
if (!dfile[0]) {
if (!strcmp(argv[opt], "-")) {
/* File name set to '-' */
set_default_file(&rectime, dfile);
opt++;
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Bad option */
usage(argv[0]);
}
else {
/* Write data to file */
strncpy(dfile, argv[opt++], MAX_FILE_LEN);
dfile[MAX_FILE_LEN - 1] = '\0';
}
}
else {
/* File already specified */
usage(argv[0]);
}
}
else if (interval < 0) {
/* Get interval */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval <= 0) {
usage(argv[0]);
}
}
else {
/* Get count value */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
if (count) {
/* Count parameter already set */
usage(argv[0]);
}
count = atol(argv[opt++]);
if (count < 0) {
usage(argv[0]);
}
else if (!count) {
count = -1; /* To generate a report continuously */
}
}
}
/* sadf reads current daily data file by default */
if (!dfile[0]) {
set_default_file(&rectime, dfile);
}
if (tm_start.use && tm_end.use && (tm_end.tm_hour < tm_start.tm_hour)) {
tm_end.tm_hour += 24;
}
if (USE_PRETTY_OPTION(flags)) {
dm_major = get_devmap_major();
}
/*
* Display all the contents of the daily data file if the count parameter
* was not set on the command line.
*/
if (!count) {
count = -1;
}
/* Default is CPU activity */
select_default_activity(act);
/* Check options consistency with selected output format. Default is PPC display */
check_format_options();
if (interval < 0) {
interval = 1;
}
/* Read stats from file */
read_stats_from_file(dfile);
/* Free bitmaps */
free_bitmaps(act);
return 0;
}
/*
***************************************************************************
* Main entry to the sadf program
***************************************************************************
*/
int main(int argc, char **argv)
{
int opt = 1, sar_options = 0;
int day_offset = 0;
int i, rc;
char dfile[MAX_FILE_LEN];
char *t;
/* Get HZ */
get_HZ();
/* Compute page shift in kB */
get_kb_shift();
dfile[0] = '\0';
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
tm_start.use = tm_end.use = FALSE;
/* Allocate and init activity bitmaps */
allocate_bitmaps(act);
/* Init some structures */
init_structures();
/* Process options */
while (opt < argc) {
if (!strcmp(argv[opt], "-I")) {
if (argv[++opt] && sar_options) {
if (parse_sar_I_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-P")) {
if (parse_sa_P_opt(argv, &opt, &flags, act)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-s")) {
/* Get time start */
if (parse_timestamp(argv, &opt, &tm_start, DEF_TMSTART)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-e")) {
/* Get time end */
if (parse_timestamp(argv, &opt, &tm_end, DEF_TMEND)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-O")) {
/* Parse SVG options */
if (!argv[++opt] || sar_options) {
usage(argv[0]);
}
for (t = strtok(argv[opt], ","); t; t = strtok(NULL, ",")) {
if (!strcmp(t, K_SKIP_EMPTY)) {
flags |= S_F_SVG_SKIP;
}
else if (!strcmp(t, K_AUTOSCALE)) {
flags |= S_F_SVG_AUTOSCALE;
}
else {
usage(argv[0]);
}
}
opt++;
}
else if ((strlen(argv[opt]) > 1) &&
(strlen(argv[opt]) < 4) &&
!strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt] + 1, DIGITS) == (strlen(argv[opt]) - 1))) {
if (dfile[0] || day_offset) {
/* File already specified */
usage(argv[0]);
}
day_offset = atoi(argv[opt++] + 1);
}
else if (!strcmp(argv[opt], "--")) {
sar_options = 1;
opt++;
}
else if (!strcmp(argv[opt], "-m")) {
if (argv[++opt] && sar_options) {
/* Parse sar's option -m */
if (parse_sar_m_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-n")) {
if (argv[++opt] && sar_options) {
/* Parse sar's option -n */
if (parse_sar_n_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Other options not previously tested */
if (sar_options) {
if ((rc = parse_sar_opt(argv, &opt, act, &flags, C_SADF)) != 0) {
if (rc == 1) {
usage(argv[0]);
}
exit(1);
}
}
else {
for (i = 1; *(argv[opt] + i); i++) {
switch (*(argv[opt] + i)) {
case 'C':
flags |= S_F_COMMENT;
break;
case 'c':
if (format) {
usage(argv[0]);
}
format = F_CONV_OUTPUT;
break;
case 'd':
if (format) {
usage(argv[0]);
}
format = F_DB_OUTPUT;
break;
case 'g':
if (format) {
usage(argv[0]);
}
format = F_SVG_OUTPUT;
break;
case 'h':
flags |= S_F_HORIZONTALLY;
break;
case 'H':
flags |= S_F_HDR_ONLY;
break;
case 'j':
if (format) {
usage(argv[0]);
}
format = F_JSON_OUTPUT;
break;
case 'p':
if (format) {
usage(argv[0]);
}
format = F_PPC_OUTPUT;
break;
case 'T':
flags |= S_F_LOCAL_TIME;
break;
case 't':
flags |= S_F_TRUE_TIME;
break;
case 'U':
flags |= S_F_SEC_EPOCH;
break;
case 'x':
if (format) {
usage(argv[0]);
}
format = F_XML_OUTPUT;
break;
case 'V':
print_version();
break;
default:
usage(argv[0]);
}
}
}
opt++;
}
/* Get data file name */
else if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
if (dfile[0] || day_offset) {
/* File already specified */
usage(argv[0]);
}
if (!strcmp(argv[opt], "-")) {
/* File name set to '-' */
set_default_file(dfile, 0, -1);
opt++;
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Bad option */
usage(argv[0]);
}
else {
/* Write data to file */
strncpy(dfile, argv[opt++], MAX_FILE_LEN);
dfile[MAX_FILE_LEN - 1] = '\0';
/* Check if this is an alternate directory for sa files */
check_alt_sa_dir(dfile, 0, -1);
}
}
else if (interval < 0) {
/* Get interval */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval <= 0) {
usage(argv[0]);
}
}
else {
/* Get count value */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
if (count) {
/* Count parameter already set */
usage(argv[0]);
}
count = atol(argv[opt++]);
if (count < 0) {
usage(argv[0]);
}
else if (!count) {
count = -1; /* To generate a report continuously */
}
}
}
/* sadf reads current daily data file by default */
if (!dfile[0]) {
set_default_file(dfile, day_offset, -1);
}
if (tm_start.use && tm_end.use && (tm_end.tm_hour < tm_start.tm_hour)) {
tm_end.tm_hour += 24;
}
if (USE_PRETTY_OPTION(flags)) {
dm_major = get_devmap_major();
}
/* Options -T, -t and -U are mutually exclusive */
if ((PRINT_LOCAL_TIME(flags) + PRINT_TRUE_TIME(flags) +
PRINT_SEC_EPOCH(flags)) > 1) {
usage(argv[0]);
}
/*
* Display all the contents of the daily data file if the count parameter
* was not set on the command line.
*/
if (!count) {
count = -1;
}
/* Default is CPU activity */
select_default_activity(act);
/* Check options consistency with selected output format. Default is PPC display */
check_format_options();
if (interval < 0) {
interval = 1;
}
if (format == F_CONV_OUTPUT) {
/* Convert file to current format */
convert_file(dfile, act);
}
else {
/* Read stats from file */
read_stats_from_file(dfile);
}
/* Free bitmaps */
free_bitmaps(act);
return 0;
}
/**************************************************************************
Main entry point for freeciv-ruledit
**************************************************************************/
int main(int argc, char **argv)
{
enum log_level loglevel = LOG_NORMAL;
int ui_options;
init_nls();
#ifdef ENABLE_NLS
(void) bindtextdomain("freeciv-ruledit", LOCALEDIR);
#endif
registry_module_init();
init_character_encodings(FC_DEFAULT_DATA_ENCODING, FALSE);
log_init(NULL, loglevel, NULL, NULL, -1);
ui_options = re_parse_cmdline(argc, argv);
if (ui_options != -1) {
init_connections();
settings_init(FALSE);
/* Reset aifill to zero */
game.info.aifill = 0;
game_init();
i_am_server();
if (source_rs != NULL) {
sz_strlcpy(game.server.rulesetdir, source_rs);
}
if (load_rulesets(NULL, FALSE)) {
log_normal("Terrains: %d", game.control.terrain_count);
log_normal("Resources: %d", game.control.resource_count);
log_normal("Techs: %d", game.control.num_tech_types);
log_normal("Unit classes: %d", game.control.num_unit_classes);
log_normal("Unit types: %d", game.control.num_unit_types);
log_normal("Buildings: %d", game.control.num_impr_types);
log_normal("Nations: %d", game.control.nation_count);
log_normal("City Styles: %d", game.control.styles_count);
log_normal("Specialists: %d", game.control.num_specialist_types);
log_normal("Governments: %d", game.control.government_count);
log_normal("Disasters: %d", game.control.num_disaster_types);
log_normal("Achievements: %d", game.control.num_achievement_types);
log_normal("Extras: %d", game.control.num_extra_types);
log_normal("Bases: %d", game.control.num_base_types);
log_normal("Roads: %d", game.control.num_road_types);
ruledit_qt_setup(ui_options, argv);
ruledit_qt_run();
ruledit_qt_close();
} else {
log_error("Loading ruleset %s failed", game.server.rulesetdir);
}
}
log_close();
registry_module_close();
return EXIT_SUCCESS;
}
