static void
xmms_replaygain_config_changed (xmms_object_t *obj, xmmsv_t *_val, gpointer udata)
{
const gchar *name;
xmms_xform_t *xform = udata;
xmms_replaygain_data_t *data;
gboolean dirty = FALSE;
const char *value;
data = xmms_xform_private_data_get (xform);
g_return_if_fail (data);
name = xmms_config_property_get_name ((xmms_config_property_t *) obj);
value = xmms_config_property_get_string ((xmms_config_property_t *) obj);
if (!g_ascii_strcasecmp (name, "replaygain.mode")) {
data->mode = parse_mode (value);
dirty = TRUE;
} else if (!g_ascii_strcasecmp (name,
"replaygain.use_anticlip")) {
data->use_anticlip = !!atoi (value);
dirty = TRUE;
} else if (!g_ascii_strcasecmp (name,
"replaygain.preamp")) {
data->preamp = pow (10.0, atof (value) / 20.0);
dirty = TRUE;
} else if (!g_ascii_strcasecmp (name, "replaygain.enabled")) {
data->enabled = !!atoi (value);
}
if (dirty) {
compute_gain (xform, data);
}
}
extern int mkfifo_main(int argc, char **argv)
{
char *thisarg;
mode_t mode = 0666;
argc--;
argv++;
/* Parse any options */
while (argc > 1) {
if (**argv != '-')
show_usage();
thisarg = *argv;
thisarg++;
switch (*thisarg) {
case 'm':
argc--;
argv++;
parse_mode(*argv, &mode);
break;
default:
show_usage();
}
argc--;
argv++;
}
if (argc < 1 || *argv[0] == '-')
show_usage();
if (mkfifo(*argv, mode) < 0)
perror_msg_and_die("mkfifo");
return EXIT_SUCCESS;
}
void parse_cmdline(char *cmdline, videomode_t *mode, char *log, int *kms)
{
char *p = cmdline;
char c = *p++;
while( c )
{
if( c == '-')
{
switch(*p++)
{
case 'b':
radeon_benchmarking = 1;
break;
case 'l':
p = parse_path(p, log);
break;
case 'm':
p = parse_mode(p, mode);
break;
case 'n':
*kms = 0;
};
};
c = *p++;
};
};
int
m_nick(user_t *cptr, int parc, char **parv)
{
/* :irc.lslandgirls.org NICK Flat-Line 1 1007155636 flatline islandgirls.org irc.islandgirls.org :blah blah */
/* :wiz NICK blah :1007165553 */
/* NICK wiz6 1 1021703400 +iw jason rr.wiz.cx h6.wiz.cx :monkey mushroom */
if (parc < 7)
return change_user_nick(parv[0], parv[1]);
switch (me.servtype) {
case SERV_IRCNN:
if (strncasecmp(parv[6], "services", 8) == 0) {
add_user(parv[1], parv[4], parv[5], parv[7], parv[6], NOKILL);
return 1;
}
if (match_snuggle(parv[1], parv[4], parv[5], parv[7]))
return 1;
check_clone(parv[1], parv[5]);
if (!(cptr = add_user(parv[1], parv[4], parv[5], parv[7], parv[6], NOPRIV)))
break;
break;
case SERV_HYBRD:
if (match_snuggle(parv[1], parv[5], parv[6], parv[8]))
return 1;
check_clone(parv[1], parv[6]);
if (!(cptr = add_user(parv[1], parv[5], parv[6], parv[8], parv[7], NOPRIV)))
break;
parse_mode(cptr, parv[4]);
break;
}
return 1;
}
/** Open a stream.
*
* @param path Path of the file to open.
* @param mode Mode string, (r|w|a)[b|t][+].
*
*/
FILE *fopen(const char *path, const char *mode)
{
int flags;
if (!parse_mode(mode, &flags))
return NULL;
/* Open file. */
FILE *stream = malloc(sizeof(FILE));
if (stream == NULL) {
errno = ENOMEM;
return NULL;
}
stream->fd = open(path, flags, 0666);
if (stream->fd < 0) {
/* errno was set by open() */
free(stream);
return NULL;
}
stream->error = false;
stream->eof = false;
stream->klog = false;
stream->sess = NULL;
stream->need_sync = false;
_setvbuf(stream);
list_append(&stream->link, &files);
return stream;
}
extern int mkdir_main (int argc, char **argv)
{
mode_t mode = -1;
int flags = 0;
int status = 0;
int i, opt;
while ((opt = getopt (argc, argv, "m:p")) != -1) {
switch (opt) {
case 'm':
mode = 0777;
if (!parse_mode (optarg, &mode))
error_msg_and_die ("invalid mode `%s'", optarg);
break;
case 'p':
flags |= FILEUTILS_RECUR;
break;
default:
show_usage ();
}
}
if (optind == argc)
show_usage ();
for (i = optind; i < argc; i++)
if (make_directory (argv[i], mode, flags) < 0)
status = 1;
return status;
}
static __init int sysfb_init(void)
{
struct screen_info *si = &screen_info;
struct simplefb_platform_data mode;
struct platform_device *pd;
const char *name;
bool compatible;
int ret;
sysfb_apply_efi_quirks();
/* try to create a simple-framebuffer device */
compatible = parse_mode(si, &mode);
if (compatible) {
ret = create_simplefb(si, &mode);
if (!ret)
return 0;
}
/* if the FB is incompatible, create a legacy framebuffer device */
if (si->orig_video_isVGA == VIDEO_TYPE_EFI)
name = "efi-framebuffer";
else if (si->orig_video_isVGA == VIDEO_TYPE_VLFB)
name = "vesa-framebuffer";
else
name = "platform-framebuffer";
pd = platform_device_register_resndata(NULL, name, 0,
NULL, 0, si, sizeof(*si));
return IS_ERR(pd) ? PTR_ERR(pd) : 0;
}
struct rtgui_filerw* rtgui_filerw_create_file(const char* filename, const char* mode)
{
int fd;
struct rtgui_filerw_stdio *rw;
RT_ASSERT(filename != RT_NULL);
rw = RT_NULL;
fd = open(filename, parse_mode(mode), 0);
if ( fd >= 0 ) {
rw = (struct rtgui_filerw_stdio*) rtgui_malloc(sizeof(struct rtgui_filerw_stdio));
if (rw != RT_NULL) {
rw->parent.seek = stdio_seek;
rw->parent.read = stdio_read;
rw->parent.write = stdio_write;
rw->parent.tell = stdio_tell;
rw->parent.close = stdio_close;
rw->parent.eof = stdio_eof;
rw->fd = fd;
rw->eof = RT_FALSE;
}
}
return &(rw->parent);
}
static int fileAction(const char *fileName, struct stat *statbuf, void* junk)
{
if (!parse_mode((char *)junk, &(statbuf->st_mode)))
error_msg_and_die("internal error");
if (chmod(fileName, statbuf->st_mode) == 0)
return (TRUE);
perror(fileName);
return (FALSE);
}
/** Change protection mode on a file.
* @return 1 if successful.
*/
int ccp4_utils_chmod (const char *path, const char *cmode)
{
#if defined(_WIN32)
return (chmod(path,0x0fff));
#else
unsigned mode = parse_mode(cmode);
return (chmod(path, (mode_t) mode));
#endif
}
static void parse_command_line(int argc, char *argv[])
{
int curopt;
opterr = 0;
while ((curopt = getopt_long(argc, argv, "vkD:p:n:m:", options, NULL)) != -1)
{
switch (curopt) {
case OPT_MODE:
global_options.mode = parse_mode(optarg);
break;
case 'v':
global_options.verbose++;
break;
case OPT_HISTORY:
global_options.sndhistory = atoi(optarg);
break;
case 'p': case OPT_PORT:
global_options.local_port = atoi(optarg);
break;
case 'n': case OPT_NWORKERS:
global_options.nworkers = atoi(optarg);
break;
case 'D': case OPT_DEVICE:
global_options.device = optarg;
break;
case 'm': case OPT_NVERIFIERS:
global_options.nverifiers = atoi(optarg);
break;
case 'k': case OPT_KEEP:
global_options.keep = 1;
break;
case OPT_WLSERVER:
global_options.whitelist_server = optarg;
break;
case OPT_WLPORT:
global_options.whitelist_port = atoi(optarg);
break;
case OPT_VFYSERVER:
global_options.verify_server = optarg;
break;
case OPT_VFYPORT:
global_options.verify_port = atoi(optarg);
break;
case OPT_VERIFY_PROG:
global_options.verify_prog = optarg;
break;
case OPT_VERIFY_THRESH:
global_options.verify_thresh = atoi(optarg);
break;
default:
usage(argv[0]);
break;
};
}
}
int
m_mode(user_t *cptr, int parc, char **parv)
{
/* ircnn :Flat-Line MODE Flat-Line :+giow */
/* hybrid does it through the NICK command and MODE command */
if (!cptr || parv[1][0] == '#' || parv[1][0] == '&' || !parv[2])
return -1;
parse_mode(cptr, parv[2]);
return 1;
}
ATF_TC_BODY(parse_mode, tc)
{
void *set;
set = parse_mode("u+x");
ATF_REQUIRE(set == NULL);
set = parse_mode("plop");
ATF_REQUIRE(set == NULL);
set = parse_mode("0755");
ATF_REQUIRE(set != NULL);
free(set);
set = parse_mode("u=r,g=rX");
ATF_REQUIRE(set != NULL);
free(set);
}
static void test_parse_mode(void) {
mode_t m;
assert_se(parse_mode("-1", &m) < 0);
assert_se(parse_mode("", &m) < 0);
assert_se(parse_mode("888", &m) < 0);
assert_se(parse_mode("77777", &m) < 0);
assert_se(parse_mode("544", &m) >= 0 && m == 0544);
assert_se(parse_mode("777", &m) >= 0 && m == 0777);
assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
assert_se(parse_mode("0", &m) >= 0 && m == 0);
}
static void ratelimit_parse(struct xt_option_call *cb)
{
struct xt_ratelimit_mtinfo *info = cb->data;
xtables_option_parse(cb);
switch (cb->entry->id) {
case O_MODE:
if (parse_mode(&info->mode, cb->arg) < 0)
xtables_param_act(XTF_BAD_VALUE, "ratelimit",
"--ratelimit-mode", cb->arg);
break;
}
}
static void posarg(int i, const char *arg) {
(void)i;
switch(i) {
case 0:
if( opt_verbosity ) {
fprintf( stderr, "Setting command: %s\n", arg );
}
if( 0 == strcasecmp(arg, "chmod") ) {
set_cmd( cmd_chmod );
} else if( 0 == strcasecmp(arg, "create") ||
0 == strcasecmp(arg, "mk") ||
0 == strcasecmp(arg, "make") )
{
set_cmd( cmd_create );
} else if( 0 == strcasecmp(arg, "unlink") ||
0 == strcasecmp(arg, "rm") ||
0 == strcasecmp(arg, "remove") )
{
set_cmd( cmd_unlink );
} else if( 0 == strcasecmp(arg, "dump") ) {
set_cmd( cmd_dump );
} else if( 0 == strcasecmp(arg, "file") ) {
set_cmd( cmd_file );
} else if( 0 == strcasecmp(arg, "search") ) {
set_cmd( cmd_search );
} else {
goto INVALID;
}
break;
case 1:
if( cmd_chmod == opt_command ) {
opt_mode = parse_mode( arg );
} else {
opt_chan_name = strdup( arg );
}
break;
case 2:
if( cmd_chmod == opt_command ) {
opt_chan_name = strdup( arg );
} else if (cmd_search == opt_command ) {
opt_domain = strdup(arg);
} else {
goto INVALID;
}
break;
default:
INVALID:
fprintf( stderr, "Invalid argument: %s\n", arg );
exit(EXIT_FAILURE);
}
}
static bool
parse_command_line( int argc, char *argv[] )
{
int n;
for (n = 1; n < argc; n++) {
const char *arg = argv[n];
if (strcmp (arg, "-h") == 0 || strcmp (arg, "--help") == 0) {
print_usage (argv[0]);
return false;
}
if (strcmp (arg, "-v") == 0 || strcmp (arg, "--version") == 0) {
fprintf (stderr, "dfbg version %s\n", DIRECTFB_VERSION);
return false;
}
if (strcmp (arg, "-m") == 0 || strcmp (arg, "--mode") == 0) {
if (++n == argc) {
print_usage (argv[0]);
return false;
}
if (!parse_mode( argv[n] ))
return false;
continue;
}
if (strcmp (arg, "-f") == 0 || strcmp (arg, "--format") == 0) {
if (++n == argc) {
print_usage (argv[0]);
return false;
}
if (!parse_format( argv[n] ))
return false;
continue;
}
print_usage (argv[0]);
return false;
}
return true;
}
int chmod_main(int argc, char **argv)
{
int i;
int opt;
int recursiveFlag = FALSE;
int opt_eq_modeFlag = FALSE;
/* do normal option parsing */
while ((opt = getopt(argc, argv, "Rrwxst")) > 0) {
switch (opt) {
case 'R':
recursiveFlag = TRUE;
break;
case 'r':
case 'w':
case 'x':
case 's':
case 't':
opt_eq_modeFlag = TRUE;
break;
default:
show_usage();
}
}
if (opt_eq_modeFlag == TRUE) {
optind--;
}
if (argc > optind && argc > 2 && argv[optind]) {
/* Parse the specified mode */
mode_t mode;
if (parse_mode(argv[optind], &mode) == FALSE) {
error_msg_and_die( "unknown mode: %s", argv[optind]);
}
} else {
error_msg_and_die(too_few_args);
}
/* Ok, ready to do the deed now */
for (i = optind + 1; i < argc; i++) {
if (recursive_action (argv[i], recursiveFlag, FALSE, FALSE, fileAction,
fileAction, argv[optind]) == FALSE) {
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
/** .
*
* @return 1 if successful.
*/
int ccp4_utils_mkdir (const char *path, const char *cmode)
{
int result;
#if defined(_WIN32)
result = mkdir(path);
#else
unsigned mode = parse_mode(cmode);
result = mkdir(path, (mode_t) mode);
#endif
if (result == -1) {
if (errno == EEXIST) {
result = 1;
}
}
return (result);
}
int main(int argc, char *argv[])
{
int ret = 0;
int i, j;
int c;
static struct option long_opts[] = {
{"help", no_argument, NULL, 'h'},
{"task", required_argument, NULL, 't'},
{"admin", required_argument, NULL, 'a'},
{"", required_argument, NULL, 'g'},
{"dperm", required_argument, NULL, 'd'},
{"fperm", required_argument, NULL, 'f' },
{"tperm", required_argument, NULL, 's' },
{0, 0, 0, 0},
};
uid_t tuid = CGRULE_INVALID, auid = CGRULE_INVALID;
gid_t tgid = CGRULE_INVALID, agid = CGRULE_INVALID;
struct cgroup_group_spec **cgroup_list;
struct cgroup *cgroup;
struct cgroup_controller *cgc;
/* approximation of max. numbers of groups that will be created */
int capacity = argc;
/* permission variables */
mode_t dir_mode = NO_PERMS;
mode_t file_mode = NO_PERMS;
mode_t tasks_mode = NO_PERMS;
int dirm_change = 0;
int filem_change = 0;
/* no parametr on input */
if (argc < 2) {
usage(1, argv[0]);
return -1;
}
cgroup_list = calloc(capacity, sizeof(struct cgroup_group_spec *));
if (cgroup_list == NULL) {
fprintf(stderr, "%s: out of memory\n", argv[0]);
ret = -1;
goto err;
}
/* parse arguments */
while ((c = getopt_long(argc, argv, "a:t:g:hd:f:s:", long_opts, NULL))
> 0) {
switch (c) {
case 'h':
usage(0, argv[0]);
ret = 0;
goto err;
case 'a':
/* set admin uid/gid */
if (parse_uid_gid(optarg, &auid, &agid, argv[0]))
goto err;
break;
case 't':
/* set task uid/gid */
if (parse_uid_gid(optarg, &tuid, &tgid, argv[0]))
goto err;
break;
case 'g':
ret = parse_cgroup_spec(cgroup_list, optarg, capacity);
if (ret) {
fprintf(stderr, "%s: "
"cgroup controller and path"
"parsing failed (%s)\n",
argv[0], argv[optind]);
ret = -1;
goto err;
}
break;
case 'd':
dirm_change = 1;
ret = parse_mode(optarg, &dir_mode, argv[0]);
break;
case 'f':
filem_change = 1;
ret = parse_mode(optarg, &file_mode, argv[0]);
break;
case 's':
filem_change = 1;
ret = parse_mode(optarg, &tasks_mode, argv[0]);
break;
default:
usage(1, argv[0]);
ret = -1;
goto err;
}
}
/* no cgroup name */
if (argv[optind]) {
fprintf(stderr, "%s: "
"wrong arguments (%s)\n",
argv[0], argv[optind]);
ret = -1;
goto err;
}
/* initialize libcg */
ret = cgroup_init();
if (ret) {
fprintf(stderr, "%s: "
"libcgroup initialization failed: %s\n",
argv[0], cgroup_strerror(ret));
goto err;
}
/* for each new cgroup */
for (i = 0; i < capacity; i++) {
if (!cgroup_list[i])
break;
/* create the new cgroup structure */
cgroup = cgroup_new_cgroup(cgroup_list[i]->path);
if (!cgroup) {
ret = ECGFAIL;
fprintf(stderr, "%s: can't add new cgroup: %s\n",
argv[0], cgroup_strerror(ret));
goto err;
}
/* set uid and gid for the new cgroup based on input options */
ret = cgroup_set_uid_gid(cgroup, tuid, tgid, auid, agid);
if (ret)
goto err;
/* add controllers to the new cgroup */
j = 0;
while (cgroup_list[i]->controllers[j]) {
cgc = cgroup_add_controller(cgroup,
cgroup_list[i]->controllers[j]);
if (!cgc) {
ret = ECGINVAL;
fprintf(stderr, "%s: "
"controller %s can't be add\n",
argv[0],
cgroup_list[i]->controllers[j]);
cgroup_free(&cgroup);
goto err;
}
j++;
}
/* all variables set so create cgroup */
if (dirm_change | filem_change)
cgroup_set_permissions(cgroup, dir_mode, file_mode,
tasks_mode);
ret = cgroup_create_cgroup(cgroup, 0);
if (ret) {
fprintf(stderr, "%s: "
"can't create cgroup %s: %s\n",
argv[0], cgroup->name, cgroup_strerror(ret));
cgroup_free(&cgroup);
goto err;
}
cgroup_free(&cgroup);
}
err:
if (cgroup_list) {
for (i = 0; i < capacity; i++) {
if (cgroup_list[i])
cgroup_free_group_spec(cgroup_list[i]);
}
free(cgroup_list);
}
return ret;
}
/**
* gst_rtsp_transport_parse:
* @str: a transport string
* @transport: a #GstRTSPTransport
*
* Parse the RTSP transport string @str into @transport.
*
* Returns: a #GstRTSPResult.
*/
GstRTSPResult
gst_rtsp_transport_parse (const gchar * str, GstRTSPTransport * transport)
{
gchar **split, *down, **transp = NULL;
guint transport_params = 0;
gint i, count;
g_return_val_if_fail (transport != NULL, GST_RTSP_EINVAL);
g_return_val_if_fail (str != NULL, GST_RTSP_EINVAL);
gst_rtsp_transport_init (transport);
/* case insensitive */
down = g_ascii_strdown (str, -1);
split = g_strsplit (down, ";", 0);
g_free (down);
/* First field contains the transport/profile/lower_transport */
if (split[0] == NULL)
goto invalid_transport;
transp = g_strsplit (split[0], "/", 0);
if (transp[0] == NULL || transp[1] == NULL)
goto invalid_transport;
for (i = 0; transports[i].name; i++)
if (strcmp (transp[0], transports[i].name) == 0)
break;
transport->trans = transports[i].mode;
if (transport->trans != GST_RTSP_TRANS_RDT) {
for (i = 0; profiles[i].name; i++)
if (strcmp (transp[1], profiles[i].name) == 0)
break;
transport->profile = profiles[i].profile;
count = 2;
} else {
/* RDT has transport/lower_transport */
transport->profile = GST_RTSP_PROFILE_AVP;
count = 1;
}
if (transp[count] != NULL) {
for (i = 0; ltrans[i].name; i++)
if (strcmp (transp[count], ltrans[i].name) == 0)
break;
transport->lower_transport = ltrans[i].ltrans;
} else {
/* specifying the lower transport is optional */
if (transport->trans == GST_RTSP_TRANS_RTP &&
transport->profile == GST_RTSP_PROFILE_AVP)
transport->lower_transport = GST_RTSP_LOWER_TRANS_UDP_MCAST;
else
transport->lower_transport = GST_RTSP_LOWER_TRANS_UNKNOWN;
}
g_strfreev (transp);
transp = NULL;
if (transport->trans == GST_RTSP_TRANS_UNKNOWN ||
transport->profile == GST_RTSP_PROFILE_UNKNOWN ||
transport->lower_transport == GST_RTSP_LOWER_TRANS_UNKNOWN)
goto unsupported_transport;
i = 1;
while (split[i]) {
if (strcmp (split[i], "multicast") == 0) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_DELIVERY);
if (transport->lower_transport == GST_RTSP_LOWER_TRANS_TCP)
goto invalid_transport;
transport->lower_transport = GST_RTSP_LOWER_TRANS_UDP_MCAST;
} else if (strcmp (split[i], "unicast") == 0) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_DELIVERY);
if (transport->lower_transport == GST_RTSP_LOWER_TRANS_UDP_MCAST)
transport->lower_transport = GST_RTSP_LOWER_TRANS_UDP;
} else if (g_str_has_prefix (split[i], "destination=")) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_DESTINATION);
transport->destination = g_strdup (split[i] + 12);
} else if (g_str_has_prefix (split[i], "source=")) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_SOURCE);
transport->source = g_strdup (split[i] + 7);
} else if (g_str_has_prefix (split[i], "layers=")) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_LAYERS);
transport->layers = strtoul (split[i] + 7, NULL, 10);
} else if (g_str_has_prefix (split[i], "mode=")) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_MODE);
parse_mode (transport, split[i] + 5);
if (!transport->mode_play && !transport->mode_record)
goto invalid_transport;
} else if (strcmp (split[i], "append") == 0) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_APPEND);
transport->append = TRUE;
} else if (g_str_has_prefix (split[i], "interleaved=")) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_INTERLEAVED);
parse_range (split[i] + 12, &transport->interleaved);
if (!IS_VALID_INTERLEAVE_RANGE (transport->interleaved))
goto invalid_transport;
} else if (g_str_has_prefix (split[i], "ttl=")) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_TTL);
transport->ttl = strtoul (split[i] + 4, NULL, 10);
if (transport->ttl >= 256)
goto invalid_transport;
} else if (g_str_has_prefix (split[i], "port=")) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_PORT);
if (parse_range (split[i] + 5, &transport->port)) {
if (!IS_VALID_PORT_RANGE (transport->port))
goto invalid_transport;
}
} else if (g_str_has_prefix (split[i], "client_port=")) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_CLIENT_PORT);
if (parse_range (split[i] + 12, &transport->client_port)) {
if (!IS_VALID_PORT_RANGE (transport->client_port))
goto invalid_transport;
}
} else if (g_str_has_prefix (split[i], "server_port=")) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_SERVER_PORT);
if (parse_range (split[i] + 12, &transport->server_port)) {
if (!IS_VALID_PORT_RANGE (transport->server_port))
goto invalid_transport;
}
} else if (g_str_has_prefix (split[i], "ssrc=")) {
RTSP_TRANSPORT_PARAMETER_IS_UNIQUE (RTSP_TRANSPORT_SSRC);
transport->ssrc = strtoul (split[i] + 5, NULL, 16);
} else {
/* unknown field... */
if (strlen (split[i]) > 0) {
g_warning ("unknown transport field \"%s\"", split[i]);
}
}
i++;
}
g_strfreev (split);
return GST_RTSP_OK;
unsupported_transport:
{
g_strfreev (split);
return GST_RTSP_ERROR;
}
invalid_transport:
{
g_strfreev (transp);
g_strfreev (split);
return GST_RTSP_EINVAL;
}
}
int main(int argc, char **argv)
{
int devnull_fd = -1;
#ifdef TIOCNOTTY
int tty_fd = -1;
#endif
#ifdef HAVE_PAM
pam_handle_t *pamh = NULL;
int pamr;
const char *const *pamenv = NULL;
#endif
int opt;
bool start = false;
bool stop = false;
bool oknodo = false;
bool test = false;
char *exec = NULL;
char *startas = NULL;
char *name = NULL;
char *pidfile = NULL;
char *retry = NULL;
int sig = -1;
int nicelevel = 0, ionicec = -1, ioniced = 0;
bool background = false;
bool makepidfile = false;
bool interpreted = false;
bool progress = false;
uid_t uid = 0;
gid_t gid = 0;
char *home = NULL;
int tid = 0;
char *redirect_stderr = NULL;
char *redirect_stdout = NULL;
int stdin_fd;
int stdout_fd;
int stderr_fd;
pid_t pid, spid;
int i;
char *svcname = getenv("RC_SVCNAME");
RC_STRINGLIST *env_list;
RC_STRING *env;
char *tmp, *newpath, *np;
char *p;
char *token;
char exec_file[PATH_MAX];
struct passwd *pw;
struct group *gr;
char line[130];
FILE *fp;
size_t len;
mode_t numask = 022;
char **margv;
unsigned int start_wait = 0;
applet = basename_c(argv[0]);
TAILQ_INIT(&schedule);
#ifdef DEBUG_MEMORY
atexit(cleanup);
#endif
signal_setup(SIGINT, handle_signal);
signal_setup(SIGQUIT, handle_signal);
signal_setup(SIGTERM, handle_signal);
if ((tmp = getenv("SSD_NICELEVEL")))
if (sscanf(tmp, "%d", &nicelevel) != 1)
eerror("%s: invalid nice level `%s' (SSD_NICELEVEL)",
applet, tmp);
/* Get our user name and initial dir */
p = getenv("USER");
home = getenv("HOME");
if (home == NULL || p == NULL) {
pw = getpwuid(getuid());
if (pw != NULL) {
if (p == NULL)
setenv("USER", pw->pw_name, 1);
if (home == NULL) {
setenv("HOME", pw->pw_dir, 1);
home = pw->pw_dir;
}
}
}
while ((opt = getopt_long(argc, argv, getoptstring, longopts,
(int *) 0)) != -1)
switch (opt) {
case 'I': /* --ionice */
if (sscanf(optarg, "%d:%d", &ionicec, &ioniced) == 0)
eerrorx("%s: invalid ionice `%s'",
applet, optarg);
if (ionicec == 0)
ioniced = 0;
else if (ionicec == 3)
ioniced = 7;
ionicec <<= 13; /* class shift */
break;
case 'K': /* --stop */
stop = true;
break;
case 'N': /* --nice */
if (sscanf(optarg, "%d", &nicelevel) != 1)
eerrorx("%s: invalid nice level `%s'",
applet, optarg);
break;
case 'P': /* --progress */
progress = true;
break;
case 'R': /* --retry <schedule>|<timeout> */
retry = optarg;
break;
case 'S': /* --start */
start = true;
break;
case 'b': /* --background */
background = true;
break;
case 'c': /* --chuid <username>|<uid> */
/* DEPRECATED */
ewarn("WARNING: -c/--chuid is deprecated and will be removed in the future, please use -u/--user instead");
case 'u': /* --user <username>|<uid> */
{
p = optarg;
tmp = strsep(&p, ":");
changeuser = xstrdup(tmp);
if (sscanf(tmp, "%d", &tid) != 1)
pw = getpwnam(tmp);
else
pw = getpwuid((uid_t)tid);
if (pw == NULL)
eerrorx("%s: user `%s' not found",
applet, tmp);
uid = pw->pw_uid;
home = pw->pw_dir;
unsetenv("HOME");
if (pw->pw_dir)
setenv("HOME", pw->pw_dir, 1);
unsetenv("USER");
if (pw->pw_name)
setenv("USER", pw->pw_name, 1);
if (gid == 0)
gid = pw->pw_gid;
if (p) {
tmp = strsep (&p, ":");
if (sscanf(tmp, "%d", &tid) != 1)
gr = getgrnam(tmp);
else
gr = getgrgid((gid_t) tid);
if (gr == NULL)
eerrorx("%s: group `%s'"
" not found",
applet, tmp);
gid = gr->gr_gid;
}
}
break;
case 'd': /* --chdir /new/dir */
ch_dir = optarg;
break;
case 'e': /* --env */
putenv(optarg);
break;
case 'g': /* --group <group>|<gid> */
if (sscanf(optarg, "%d", &tid) != 1)
gr = getgrnam(optarg);
else
gr = getgrgid((gid_t)tid);
if (gr == NULL)
eerrorx("%s: group `%s' not found",
applet, optarg);
gid = gr->gr_gid;
break;
case 'i': /* --interpreted */
interpreted = true;
break;
case 'k':
if (parse_mode(&numask, optarg))
eerrorx("%s: invalid mode `%s'",
applet, optarg);
break;
case 'm': /* --make-pidfile */
makepidfile = true;
break;
case 'n': /* --name <process-name> */
name = optarg;
break;
case 'o': /* --oknodo */
/* DEPRECATED */
ewarn("WARNING: -o/--oknodo is deprecated and will be removed in the future");
oknodo = true;
break;
case 'p': /* --pidfile <pid-file> */
pidfile = optarg;
break;
case 's': /* --signal <signal> */
sig = parse_signal(optarg);
break;
case 't': /* --test */
test = true;
break;
case 'r': /* --chroot /new/root */
ch_root = optarg;
break;
case 'a': /* --startas <name> */
/* DEPRECATED */
ewarn("WARNING: -a/--startas is deprecated and will be removed in the future, please use -x/--exec or -n/--name instead");
startas = optarg;
break;
case 'w':
if (sscanf(optarg, "%d", &start_wait) != 1)
eerrorx("%s: `%s' not a number",
applet, optarg);
break;
case 'x': /* --exec <executable> */
exec = optarg;
break;
case '1': /* --stdout /path/to/stdout.lgfile */
redirect_stdout = optarg;
break;
case '2': /* --stderr /path/to/stderr.logfile */
redirect_stderr = optarg;
break;
case_RC_COMMON_GETOPT
}
endpwent();
argc -= optind;
argv += optind;
/* Allow start-stop-daemon --signal HUP --exec /usr/sbin/dnsmasq
* instead of forcing --stop --oknodo as well */
if (!start &&
!stop &&
sig != SIGINT &&
sig != SIGTERM &&
sig != SIGQUIT &&
sig != SIGKILL)
oknodo = true;
if (!exec)
exec = startas;
else if (!name)
name = startas;
if (!exec) {
exec = *argv;
if (!exec)
exec = name;
if (name && start)
*argv = name;
} else if (name) {
*--argv = name;
++argc;
} else if (exec) {
*--argv = exec;
++argc;
};
if (stop || sig != -1) {
if (sig == -1)
sig = SIGTERM;
if (!*argv && !pidfile && !name && !uid)
eerrorx("%s: --stop needs --exec, --pidfile,"
" --name or --user", applet);
if (background)
eerrorx("%s: --background is only relevant with"
" --start", applet);
if (makepidfile)
eerrorx("%s: --make-pidfile is only relevant with"
" --start", applet);
if (redirect_stdout || redirect_stderr)
eerrorx("%s: --stdout and --stderr are only relevant"
" with --start", applet);
} else {
if (!exec)
eerrorx("%s: nothing to start", applet);
if (makepidfile && !pidfile)
eerrorx("%s: --make-pidfile is only relevant with"
" --pidfile", applet);
if ((redirect_stdout || redirect_stderr) && !background)
eerrorx("%s: --stdout and --stderr are only relevant"
" with --background", applet);
}
/* Expand ~ */
if (ch_dir && *ch_dir == '~')
ch_dir = expand_home(home, ch_dir);
if (ch_root && *ch_root == '~')
ch_root = expand_home(home, ch_root);
if (exec) {
if (*exec == '~')
exec = expand_home(home, exec);
/* Validate that the binary exists if we are starting */
if (*exec == '/' || *exec == '.') {
/* Full or relative path */
if (ch_root)
snprintf(exec_file, sizeof(exec_file),
"%s/%s", ch_root, exec);
else
snprintf(exec_file, sizeof(exec_file),
"%s", exec);
} else {
/* Something in $PATH */
p = tmp = xstrdup(getenv("PATH"));
*exec_file = '\0';
while ((token = strsep(&p, ":"))) {
if (ch_root)
snprintf(exec_file, sizeof(exec_file),
"%s/%s/%s",
ch_root, token, exec);
else
snprintf(exec_file, sizeof(exec_file),
"%s/%s", token, exec);
if (exists(exec_file))
break;
*exec_file = '\0';
}
free(tmp);
}
}
if (start && !exists(exec_file)) {
eerror("%s: %s does not exist", applet,
*exec_file ? exec_file : exec);
exit(EXIT_FAILURE);
}
/* If we don't have a pidfile we should check if it's interpreted
* or not. If it we, we need to pass the interpreter through
* to our daemon calls to find it correctly. */
if (interpreted && !pidfile) {
fp = fopen(exec_file, "r");
if (fp) {
p = fgets(line, sizeof(line), fp);
fclose(fp);
if (p != NULL && line[0] == '#' && line[1] == '!') {
p = line + 2;
/* Strip leading spaces */
while (*p == ' ' || *p == '\t')
p++;
/* Remove the trailing newline */
len = strlen(p) - 1;
if (p[len] == '\n')
p[len] = '\0';
token = strsep(&p, " ");
strncpy(exec_file, token, sizeof(exec_file));
opt = 0;
for (nav = argv; *nav; nav++)
opt++;
nav = xmalloc(sizeof(char *) * (opt + 3));
nav[0] = exec_file;
len = 1;
if (p)
nav[len++] = p;
for (i = 0; i < opt; i++)
nav[i + len] = argv[i];
nav[i + len] = '\0';
}
}
}
margv = nav ? nav : argv;
if (stop || sig != -1) {
if (sig == -1)
sig = SIGTERM;
if (!stop)
oknodo = true;
if (retry)
parse_schedule(retry, sig);
else if (test || oknodo)
parse_schedule("0", sig);
else
parse_schedule(NULL, sig);
i = run_stop_schedule(exec, (const char *const *)margv,
pidfile, uid, test, progress);
if (i < 0)
/* We failed to stop something */
exit(EXIT_FAILURE);
if (test || oknodo)
return i > 0 ? EXIT_SUCCESS : EXIT_FAILURE;
/* Even if we have not actually killed anything, we should
* remove information about it as it may have unexpectedly
* crashed out. We should also return success as the end
* result would be the same. */
if (pidfile && exists(pidfile))
unlink(pidfile);
if (svcname)
rc_service_daemon_set(svcname, exec,
(const char *const *)argv,
pidfile, false);
exit(EXIT_SUCCESS);
}
if (pidfile)
pid = get_pid(pidfile);
else
pid = 0;
if (do_stop(exec, (const char * const *)margv, pid, uid,
0, test) > 0)
eerrorx("%s: %s is already running", applet, exec);
if (test) {
if (rc_yesno(getenv("EINFO_QUIET")))
exit (EXIT_SUCCESS);
einfon("Would start");
while (argc-- > 0)
printf(" %s", *argv++);
printf("\n");
eindent();
if (uid != 0)
einfo("as user id %d", uid);
if (gid != 0)
einfo("as group id %d", gid);
if (ch_root)
einfo("in root `%s'", ch_root);
if (ch_dir)
einfo("in dir `%s'", ch_dir);
if (nicelevel != 0)
einfo("with a priority of %d", nicelevel);
if (name)
einfo ("with a process name of %s", name);
eoutdent();
exit(EXIT_SUCCESS);
}
ebeginv("Detaching to start `%s'", exec);
eindentv();
/* Remove existing pidfile */
if (pidfile)
unlink(pidfile);
if (background)
signal_setup(SIGCHLD, handle_signal);
if ((pid = fork()) == -1)
eerrorx("%s: fork: %s", applet, strerror(errno));
/* Child process - lets go! */
if (pid == 0) {
pid_t mypid = getpid();
umask(numask);
#ifdef TIOCNOTTY
tty_fd = open("/dev/tty", O_RDWR);
#endif
devnull_fd = open("/dev/null", O_RDWR);
if (nicelevel) {
if (setpriority(PRIO_PROCESS, mypid, nicelevel) == -1)
eerrorx("%s: setpritory %d: %s",
applet, nicelevel,
strerror(errno));
}
if (ionicec != -1 &&
ioprio_set(1, mypid, ionicec | ioniced) == -1)
eerrorx("%s: ioprio_set %d %d: %s", applet,
ionicec, ioniced, strerror(errno));
if (ch_root && chroot(ch_root) < 0)
eerrorx("%s: chroot `%s': %s",
applet, ch_root, strerror(errno));
if (ch_dir && chdir(ch_dir) < 0)
eerrorx("%s: chdir `%s': %s",
applet, ch_dir, strerror(errno));
if (makepidfile && pidfile) {
fp = fopen(pidfile, "w");
if (! fp)
eerrorx("%s: fopen `%s': %s", applet, pidfile,
strerror(errno));
fprintf(fp, "%d\n", mypid);
fclose(fp);
}
#ifdef HAVE_PAM
if (changeuser != NULL) {
pamr = pam_start("start-stop-daemon",
changeuser, &conv, &pamh);
if (pamr == PAM_SUCCESS)
pamr = pam_acct_mgmt(pamh, PAM_SILENT);
if (pamr == PAM_SUCCESS)
pamr = pam_open_session(pamh, PAM_SILENT);
if (pamr != PAM_SUCCESS)
eerrorx("%s: pam error: %s",
applet, pam_strerror(pamh, pamr));
}
#endif
if (gid && setgid(gid))
eerrorx("%s: unable to set groupid to %d",
applet, gid);
if (changeuser && initgroups(changeuser, gid))
eerrorx("%s: initgroups (%s, %d)",
applet, changeuser, gid);
if (uid && setuid(uid))
eerrorx ("%s: unable to set userid to %d",
applet, uid);
/* Close any fd's to the passwd database */
endpwent();
#ifdef TIOCNOTTY
ioctl(tty_fd, TIOCNOTTY, 0);
close(tty_fd);
#endif
/* Clean the environment of any RC_ variables */
env_list = rc_stringlist_new();
i = 0;
while (environ[i])
rc_stringlist_add(env_list, environ[i++]);
#ifdef HAVE_PAM
if (changeuser != NULL) {
pamenv = (const char *const *)pam_getenvlist(pamh);
if (pamenv) {
while (*pamenv) {
/* Don't add strings unless they set a var */
if (strchr(*pamenv, '='))
putenv(xstrdup(*pamenv));
else
unsetenv(*pamenv);
pamenv++;
}
}
}
#endif
TAILQ_FOREACH(env, env_list, entries) {
if ((strncmp(env->value, "RC_", 3) == 0 &&
strncmp(env->value, "RC_SERVICE=", 10) != 0 &&
strncmp(env->value, "RC_SVCNAME=", 10) != 0) ||
strncmp(env->value, "SSD_NICELEVEL=", 14) == 0)
{
p = strchr(env->value, '=');
*p = '\0';
unsetenv(env->value);
continue;
}
}
rc_stringlist_free(env_list);
/* For the path, remove the rcscript bin dir from it */
if ((token = getenv("PATH"))) {
len = strlen(token);
newpath = np = xmalloc(len + 1);
while (token && *token) {
p = strchr(token, ':');
if (p) {
*p++ = '\0';
while (*p == ':')
p++;
}
if (strcmp(token, RC_LIBEXECDIR "/bin") != 0 &&
strcmp(token, RC_LIBEXECDIR "/sbin") != 0)
{
len = strlen(token);
if (np != newpath)
*np++ = ':';
memcpy(np, token, len);
np += len;
}
token = p;
}
*np = '\0';
unsetenv("PATH");
setenv("PATH", newpath, 1);
}
stdin_fd = devnull_fd;
stdout_fd = devnull_fd;
stderr_fd = devnull_fd;
if (redirect_stdout) {
if ((stdout_fd = open(redirect_stdout,
O_WRONLY | O_CREAT | O_APPEND,
S_IRUSR | S_IWUSR)) == -1)
eerrorx("%s: unable to open the logfile"
" for stdout `%s': %s",
applet, redirect_stdout, strerror(errno));
}
if (redirect_stderr) {
if ((stderr_fd = open(redirect_stderr,
O_WRONLY | O_CREAT | O_APPEND,
S_IRUSR | S_IWUSR)) == -1)
eerrorx("%s: unable to open the logfile"
" for stderr `%s': %s",
applet, redirect_stderr, strerror(errno));
}
if (background)
dup2(stdin_fd, STDIN_FILENO);
if (background || redirect_stdout || rc_yesno(getenv("EINFO_QUIET")))
dup2(stdout_fd, STDOUT_FILENO);
if (background || redirect_stderr || rc_yesno(getenv("EINFO_QUIET")))
dup2(stderr_fd, STDERR_FILENO);
for (i = getdtablesize() - 1; i >= 3; --i)
close(i);
setsid();
execvp(exec, argv);
#ifdef HAVE_PAM
if (changeuser != NULL && pamr == PAM_SUCCESS)
pam_close_session(pamh, PAM_SILENT);
#endif
eerrorx("%s: failed to exec `%s': %s",
applet, exec,strerror(errno));
}
static gboolean
xmms_replaygain_init (xmms_xform_t *xform)
{
xmms_replaygain_data_t *data;
xmms_config_property_t *cfgv;
xmms_sample_format_t fmt;
g_return_val_if_fail (xform, FALSE);
data = g_new0 (xmms_replaygain_data_t, 1);
g_return_val_if_fail (data, FALSE);
xmms_xform_private_data_set (xform, data);
cfgv = xmms_xform_config_lookup (xform, "mode");
xmms_config_property_callback_set (cfgv,
xmms_replaygain_config_changed,
xform);
data->mode = parse_mode (xmms_config_property_get_string (cfgv));
cfgv = xmms_xform_config_lookup (xform, "use_anticlip");
xmms_config_property_callback_set (cfgv,
xmms_replaygain_config_changed,
xform);
data->use_anticlip = !!xmms_config_property_get_int (cfgv);
cfgv = xmms_xform_config_lookup (xform, "preamp");
xmms_config_property_callback_set (cfgv,
xmms_replaygain_config_changed,
xform);
data->preamp = pow (10.0, atof (xmms_config_property_get_string (cfgv)) / 20.0);
cfgv = xmms_xform_config_lookup (xform, "enabled");
xmms_config_property_callback_set (cfgv,
xmms_replaygain_config_changed,
xform);
data->enabled = !!xmms_config_property_get_int (cfgv);
xmms_xform_outdata_type_copy (xform);
compute_gain (xform, data);
fmt = xmms_xform_indata_get_int (xform, XMMS_STREAM_TYPE_FMT_FORMAT);
switch (fmt) {
case XMMS_SAMPLE_FORMAT_S8:
data->apply = apply_s8;
break;
case XMMS_SAMPLE_FORMAT_U8:
data->apply = apply_u8;
break;
case XMMS_SAMPLE_FORMAT_S16:
data->apply = apply_s16;
break;
case XMMS_SAMPLE_FORMAT_U16:
data->apply = apply_u16;
break;
case XMMS_SAMPLE_FORMAT_S32:
data->apply = apply_s32;
break;
case XMMS_SAMPLE_FORMAT_U32:
data->apply = apply_u32;
break;
case XMMS_SAMPLE_FORMAT_FLOAT:
data->apply = apply_float;
break;
case XMMS_SAMPLE_FORMAT_DOUBLE:
data->apply = apply_double;
break;
default:
/* we shouldn't ever get here, since we told the daemon
* earlier about this list of supported formats.
*/
g_assert_not_reached ();
break;
}
return TRUE;
}
/**
* Parse permissions, including mount-time overrides. This is roughly the same behavior as
* NTFS-3g, except that fmask and dmask override umask regardless of argument order.
*/
int permissions_setup(struct ltfs_fuse_data *priv)
{
mode_t mode;
/* Set defaults */
priv->perm_override = false;
priv->mount_uid = geteuid();
priv->mount_gid = getegid();
priv->file_mode = S_IFREG | 0777;
priv->dir_mode = S_IFDIR | 0777;
/* User ID override */
if (priv->force_uid) {
priv->perm_override = true;
priv->mount_uid = parse_uid(priv->force_uid);
if (priv->mount_uid == (uid_t)-1) {
/* Invalid UID */
ltfsmsg(LTFS_ERR, "14079E", priv->force_uid);
return -1;
}
free(priv->force_uid);
}
/* Group ID override */
if (priv->force_gid) {
priv->perm_override = true;
priv->mount_gid = parse_gid(priv->force_gid);
if (priv->mount_gid == (gid_t)-1) {
/* Invalid GID */
ltfsmsg(LTFS_ERR, "14080E", priv->force_gid);
return -1;
}
free(priv->force_gid);
}
/* Global (file and directory) permissions override */
if (priv->force_umask) {
priv->perm_override = true;
mode = parse_mode(priv->force_umask);
if (mode == (mode_t)-1) {
/* Invalid umask */
ltfsmsg(LTFS_ERR, "14006E", priv->force_umask);
return -1;
}
priv->file_mode = (S_IFREG | 0777) & ~mode;
priv->dir_mode = (S_IFDIR | 0777) & ~mode;
free(priv->force_umask);
}
/* File permissions override */
if (priv->force_fmask) {
priv->perm_override = true;
mode = parse_mode(priv->force_fmask);
if (mode == (mode_t)-1) {
/* Invalid fmask */
ltfsmsg(LTFS_ERR, "14007E", priv->force_fmask);
return -1;
}
priv->file_mode = (S_IFREG | 0777) & ~mode;
free(priv->force_fmask);
}
/* Directory permissions override */
if (priv->force_dmask) {
priv->perm_override = true;
mode = parse_mode(priv->force_dmask);
if (mode == (mode_t)-1) {
/* Invalid dmask */
ltfsmsg(LTFS_ERR, "14008E", priv->force_dmask);
return -1;
}
priv->dir_mode = (S_IFDIR | 0777) & ~mode;
free(priv->force_dmask);
}
/* Uncomment to apply the current umask to the default permissions, as vfat does.
mode = umask(0);
umask(mode);
if (! priv->force_umask && ! priv->force_fmask)
priv->file_mode = (S_IFREG | 0777) & ~mode;
if (! priv->force_umask && ! priv->force_dmask)
priv->dir_mode = (S_IFDIR | 0777) & ~mode;
*/
return 0;
}
/* Function which parses command options; returns true if it
ate an option */
static int
parse(int c, char **argv, int invert, unsigned int *flags,
const struct ipt_entry *entry,
unsigned int *nfcache,
struct ipt_entry_match **match)
{
struct ipt_hashlimit_info *r =
(struct ipt_hashlimit_info *)(*match)->data;
unsigned int num;
switch(c) {
case '%':
if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;
if (!parse_rate(optarg, &r->cfg.avg))
exit_error(PARAMETER_PROBLEM,
"bad rate `%s'", optarg);
*flags |= PARAM_LIMIT;
break;
case '$':
if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;
if (string_to_number(optarg, 0, 10000, &num) == -1)
exit_error(PARAMETER_PROBLEM,
"bad --hashlimit-burst `%s'", optarg);
r->cfg.burst = num;
*flags |= PARAM_BURST;
break;
case '&':
if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;
if (string_to_number(optarg, 0, 0xffffffff, &num) == -1)
exit_error(PARAMETER_PROBLEM,
"bad --hashlimit-htable-size: `%s'", optarg);
r->cfg.size = num;
*flags |= PARAM_SIZE;
break;
case '*':
if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;
if (string_to_number(optarg, 0, 0xffffffff, &num) == -1)
exit_error(PARAMETER_PROBLEM,
"bad --hashlimit-htable-max: `%s'", optarg);
r->cfg.max = num;
*flags |= PARAM_MAX;
break;
case '(':
if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;
if (string_to_number(optarg, 0, 0xffffffff, &num) == -1)
exit_error(PARAMETER_PROBLEM,
"bad --hashlimit-htable-gcinterval: `%s'",
optarg);
/* FIXME: not HZ dependent!! */
r->cfg.gc_interval = num;
*flags |= PARAM_GCINTERVAL;
break;
case ')':
if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;
if (string_to_number(optarg, 0, 0xffffffff, &num) == -1)
exit_error(PARAMETER_PROBLEM,
"bad --hashlimit-htable-expire: `%s'", optarg);
/* FIXME: not HZ dependent */
r->cfg.expire = num;
*flags |= PARAM_EXPIRE;
break;
case '_':
if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;
if (parse_mode(r, optarg) < 0)
exit_error(PARAMETER_PROBLEM,
"bad --hashlimit-mode: `%s'\n", optarg);
*flags |= PARAM_MODE;
break;
case '"':
if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;
if (strlen(optarg) == 0)
exit_error(PARAMETER_PROBLEM, "Zero-length name?");
strncpy(r->name, optarg, sizeof(r->name));
*flags |= PARAM_NAME;
break;
default:
return 0;
}
if (invert)
exit_error(PARAMETER_PROBLEM,
"hashlimit does not support invert");
return 1;
}
static int
hashlimit_mt_parse(struct xt_hashlimit_mtinfo1 *info, unsigned int *flags,
int c, int invert, unsigned int maxmask)
{
unsigned int num;
switch(c) {
case '%': /* --hashlimit / --hashlimit-below */
param_act(P_ONLY_ONCE, "hashlimit", "--hashlimit-upto",
*flags & PARAM_LIMIT);
if (invert)
info->cfg.mode |= XT_HASHLIMIT_INVERT;
if (!parse_rate(optarg, &info->cfg.avg))
param_act(P_BAD_VALUE, "hashlimit",
"--hashlimit-upto", optarg);
*flags |= PARAM_LIMIT;
return true;
case '^': /* --hashlimit-above == !--hashlimit-below */
param_act(P_ONLY_ONCE, "hashlimit", "--hashlimit-above",
*flags & PARAM_LIMIT);
if (!invert)
info->cfg.mode |= XT_HASHLIMIT_INVERT;
if (!parse_rate(optarg, &info->cfg.avg))
param_act(P_BAD_VALUE, "hashlimit",
"--hashlimit-above", optarg);
*flags |= PARAM_LIMIT;
return true;
case '$': /* --hashlimit-burst */
param_act(P_ONLY_ONCE, "hashlimit", "--hashlimit-burst",
*flags & PARAM_BURST);
if (!strtonum(optarg, NULL, &num, 0, 10000))
param_act(P_BAD_VALUE, "hashlimit",
"--hashlimit-burst", optarg);
info->cfg.burst = num;
*flags |= PARAM_BURST;
return true;
case '&': /* --hashlimit-htable-size */
param_act(P_ONLY_ONCE, "hashlimit", "--hashlimit-htable-size",
*flags & PARAM_SIZE);
if (!strtonum(optarg, NULL, &num, 0, 0xffffffff))
param_act(P_BAD_VALUE, "hashlimit",
"--hashlimit-htable-size", optarg);
info->cfg.size = num;
*flags |= PARAM_SIZE;
return true;
case '*': /* --hashlimit-htable-max */
param_act(P_ONLY_ONCE, "hashlimit", "--hashlimit-htable-max",
*flags & PARAM_MAX);
if (!strtonum(optarg, NULL, &num, 0, 0xffffffff))
param_act(P_BAD_VALUE, "hashlimit",
"--hashlimit-htable-max", optarg);
info->cfg.max = num;
*flags |= PARAM_MAX;
return true;
case '(': /* --hashlimit-htable-gcinterval */
param_act(P_ONLY_ONCE, "hashlimit",
"--hashlimit-htable-gcinterval",
*flags & PARAM_GCINTERVAL);
if (!strtonum(optarg, NULL, &num, 0, 0xffffffff))
param_act(P_BAD_VALUE, "hashlimit",
"--hashlimit-htable-gcinterval", optarg);
/* FIXME: not HZ dependent!! */
info->cfg.gc_interval = num;
*flags |= PARAM_GCINTERVAL;
return true;
case ')': /* --hashlimit-htable-expire */
param_act(P_ONLY_ONCE, "hashlimit",
"--hashlimit-htable-expire", *flags & PARAM_EXPIRE);
if (!strtonum(optarg, NULL, &num, 0, 0xffffffff))
param_act(P_BAD_VALUE, "hashlimit",
"--hashlimit-htable-expire", optarg);
/* FIXME: not HZ dependent */
info->cfg.expire = num;
*flags |= PARAM_EXPIRE;
return true;
case '_':
param_act(P_ONLY_ONCE, "hashlimit", "--hashlimit-mode",
*flags & PARAM_MODE);
if (parse_mode(&info->cfg.mode, optarg) < 0)
param_act(P_BAD_VALUE, "hashlimit",
"--hashlimit-mode", optarg);
*flags |= PARAM_MODE;
return true;
case '"': /* --hashlimit-name */
param_act(P_ONLY_ONCE, "hashlimit", "--hashlimit-name",
*flags & PARAM_NAME);
if (strlen(optarg) == 0)
exit_error(PARAMETER_PROBLEM, "Zero-length name?");
strncpy(info->name, optarg, sizeof(info->name));
info->name[sizeof(info->name)-1] = '\0';
*flags |= PARAM_NAME;
return true;
case '<': /* --hashlimit-srcmask */
param_act(P_ONLY_ONCE, "hashlimit", "--hashlimit-srcmask",
*flags & PARAM_SRCMASK);
if (!strtonum(optarg, NULL, &num, 0, maxmask))
param_act(P_BAD_VALUE, "hashlimit",
"--hashlimit-srcmask", optarg);
info->cfg.srcmask = num;
*flags |= PARAM_SRCMASK;
return true;
case '>': /* --hashlimit-dstmask */
param_act(P_ONLY_ONCE, "hashlimit", "--hashlimit-dstmask",
*flags & PARAM_DSTMASK);
if (!strtonum(optarg, NULL, &num, 0, maxmask))
param_act(P_BAD_VALUE, "hashlimit",
"--hashlimit-dstmask", optarg);
info->cfg.dstmask = num;
*flags |= PARAM_DSTMASK;
return true;
}
return false;
}
/*
* parse_setting() - parse a single setting of custom lcd parameters
*
* @setting: The custom lcd setting <name>:<value>
*
* Returns -1 on failure, 0 on success.
*/
static int parse_setting(char *setting)
{
int num_val;
char *setting_start = setting;
if (!strncmp(setting, "mode:", 5)) {
return parse_mode(setting + 5);
} else if (!strncmp(setting, "pixclock:", 9)) {
return parse_pixclock(setting + 9);
} else if (!strncmp(setting, "left:", 5)) {
num_val = simple_strtoul(setting + 5, &setting, 0);
panel_cfg.timing_h |= DSS_HBP(num_val);
} else if (!strncmp(setting, "right:", 6)) {
num_val = simple_strtoul(setting + 6, &setting, 0);
panel_cfg.timing_h |= DSS_HFP(num_val);
} else if (!strncmp(setting, "upper:", 6)) {
num_val = simple_strtoul(setting + 6, &setting, 0);
panel_cfg.timing_v |= DSS_VBP(num_val);
} else if (!strncmp(setting, "lower:", 6)) {
num_val = simple_strtoul(setting + 6, &setting, 0);
panel_cfg.timing_v |= DSS_VFP(num_val);
} else if (!strncmp(setting, "hsynclen:", 9)) {
num_val = simple_strtoul(setting + 9, &setting, 0);
panel_cfg.timing_h |= DSS_HSW(num_val);
} else if (!strncmp(setting, "vsynclen:", 9)) {
num_val = simple_strtoul(setting + 9, &setting, 0);
panel_cfg.timing_v |= DSS_VSW(num_val);
} else if (!strncmp(setting, "hsync:", 6)) {
if (simple_strtoul(setting + 6, &setting, 0) == 0)
panel_cfg.pol_freq |= DSS_IHS;
else
panel_cfg.pol_freq &= ~DSS_IHS;
} else if (!strncmp(setting, "vsync:", 6)) {
if (simple_strtoul(setting + 6, &setting, 0) == 0)
panel_cfg.pol_freq |= DSS_IVS;
else
panel_cfg.pol_freq &= ~DSS_IVS;
} else if (!strncmp(setting, "outputen:", 9)) {
if (simple_strtoul(setting + 9, &setting, 0) == 0)
panel_cfg.pol_freq |= DSS_IEO;
else
panel_cfg.pol_freq &= ~DSS_IEO;
} else if (!strncmp(setting, "pixclockpol:", 12)) {
if (simple_strtoul(setting + 12, &setting, 0) == 0)
panel_cfg.pol_freq |= DSS_IPC;
else
panel_cfg.pol_freq &= ~DSS_IPC;
} else if (!strncmp(setting, "active", 6)) {
panel_cfg.panel_type = ACTIVE_DISPLAY;
return 0; /* Avoid sanity check below */
} else if (!strncmp(setting, "passive", 7)) {
panel_cfg.panel_type = PASSIVE_DISPLAY;
return 0; /* Avoid sanity check below */
} else if (!strncmp(setting, "display:", 8)) {
if (!strncmp(setting + 8, "dvi", 3)) {
lcd_def = DVI_CUSTOM;
return 0; /* Avoid sanity check below */
}
} else {
printf("LCD: unknown option %s\n", setting_start);
return -1;
}
if (setting[0] != '\0') {
printf("LCD: invalid value for %s\n", setting_start);
return -1;
}
return 0;
}
static int parse(int c, char **argv, int invert, unsigned int *flags,
const struct ipt_entry *entry,
unsigned int *nfcache,
struct ipt_entry_match **match)
{
struct ipt_policy_info *info = (void *)(*match)->data;
struct ipt_policy_elem *e = &info->pol[info->len];
struct in_addr *addr = NULL, mask;
unsigned int naddr = 0;
int mode;
check_inverse(optarg, &invert, &optind, 0);
switch (c) {
case '1':
if (info->flags & (IPT_POLICY_MATCH_IN|IPT_POLICY_MATCH_OUT))
exit_error(PARAMETER_PROBLEM,
"policy match: double --dir option");
if (invert)
exit_error(PARAMETER_PROBLEM,
"policy match: can't invert --dir option");
info->flags |= parse_direction(argv[optind-1]);
break;
case '2':
if (invert)
exit_error(PARAMETER_PROBLEM,
"policy match: can't invert --policy option");
info->flags |= parse_policy(argv[optind-1]);
break;
case '3':
if (info->flags & IPT_POLICY_MATCH_STRICT)
exit_error(PARAMETER_PROBLEM,
"policy match: double --strict option");
if (invert)
exit_error(PARAMETER_PROBLEM,
"policy match: can't invert --strict option");
info->flags |= IPT_POLICY_MATCH_STRICT;
break;
case '4':
if (e->match.reqid)
exit_error(PARAMETER_PROBLEM,
"policy match: double --reqid option");
e->match.reqid = 1;
e->invert.reqid = invert;
e->reqid = strtol(argv[optind-1], NULL, 10);
break;
case '5':
if (e->match.spi)
exit_error(PARAMETER_PROBLEM,
"policy match: double --spi option");
e->match.spi = 1;
e->invert.spi = invert;
e->spi = strtol(argv[optind-1], NULL, 0x10);
break;
case '6':
if (e->match.saddr)
exit_error(PARAMETER_PROBLEM,
"policy match: double --tunnel-src option");
parse_hostnetworkmask(argv[optind-1], &addr, &mask, &naddr);
if (naddr > 1)
exit_error(PARAMETER_PROBLEM,
"policy match: name resolves to multiple IPs");
e->match.saddr = 1;
e->invert.saddr = invert;
e->saddr.a4 = addr[0];
e->smask.a4 = mask;
break;
case '7':
if (e->match.daddr)
exit_error(PARAMETER_PROBLEM,
"policy match: double --tunnel-dst option");
parse_hostnetworkmask(argv[optind-1], &addr, &mask, &naddr);
if (naddr > 1)
exit_error(PARAMETER_PROBLEM,
"policy match: name resolves to multiple IPs");
e->match.daddr = 1;
e->invert.daddr = invert;
e->daddr.a4 = addr[0];
e->dmask.a4 = mask;
break;
case '8':
if (e->match.proto)
exit_error(PARAMETER_PROBLEM,
"policy match: double --proto option");
e->proto = parse_protocol(argv[optind-1]);
if (e->proto != IPPROTO_AH && e->proto != IPPROTO_ESP &&
e->proto != IPPROTO_COMP)
exit_error(PARAMETER_PROBLEM,
"policy match: protocol must ah/esp/ipcomp");
e->match.proto = 1;
e->invert.proto = invert;
break;
case '9':
if (e->match.mode)
exit_error(PARAMETER_PROBLEM,
"policy match: double --mode option");
mode = parse_mode(argv[optind-1]);
e->match.mode = 1;
e->invert.mode = invert;
e->mode = mode;
break;
case 'a':
if (invert)
exit_error(PARAMETER_PROBLEM,
"policy match: can't invert --next option");
if (++info->len == IPT_POLICY_MAX_ELEM)
exit_error(PARAMETER_PROBLEM,
"policy match: maximum policy depth reached");
break;
default:
return 0;
}
policy_info = info;
return 1;
}
int checkpath(int argc, char **argv)
{
int opt;
uid_t uid = geteuid();
gid_t gid = getgid();
mode_t mode = 0;
struct passwd *pw = NULL;
struct group *gr = NULL;
inode_t type = inode_unknown;
int retval = EXIT_SUCCESS;
bool trunc = false;
bool chowner = false;
bool writable = false;
bool selinux_on = false;
while ((opt = getopt_long(argc, argv, getoptstring,
longopts, (int *) 0)) != -1)
{
switch (opt) {
case 'D':
trunc = true;
case 'd':
type = inode_dir;
break;
case 'F':
trunc = true;
case 'f':
type = inode_file;
break;
case 'p':
type = inode_fifo;
break;
case 'm':
if (parse_mode(&mode, optarg) != 0)
eerrorx("%s: invalid mode `%s'",
applet, optarg);
break;
case 'o':
chowner = true;
if (parse_owner(&pw, &gr, optarg) != 0)
eerrorx("%s: owner `%s' not found",
applet, optarg);
break;
case 'W':
writable = true;
break;
case_RC_COMMON_GETOPT
}
}
if (optind >= argc)
usage(EXIT_FAILURE);
if (writable && type != inode_unknown)
eerrorx("%s: -W cannot be specified along with -d, -f or -p", applet);
if (pw) {
uid = pw->pw_uid;
gid = pw->pw_gid;
}
if (gr)
gid = gr->gr_gid;
if (selinux_util_open() == 1)
selinux_on = true;
while (optind < argc) {
if (writable)
exit(!is_writable(argv[optind]));
if (do_check(argv[optind], uid, gid, mode, type, trunc, chowner, selinux_on))
retval = EXIT_FAILURE;
optind++;
}
if (selinux_on)
selinux_util_close();
return retval;
}
static DFBBoolean
parse_command_line( int argc, char *argv[] )
{
int n;
for (n = 1; n < argc; n++) {
const char *arg = argv[n];
if (strcmp (arg, "-h") == 0 || strcmp (arg, "--help") == 0) {
print_usage (argv[0]);
return DFB_FALSE;
}
if (strcmp (arg, "-v") == 0 || strcmp (arg, "--version") == 0) {
fprintf (stderr, "dfbg version %s\n", DIRECTFB_VERSION);
return DFB_FALSE;
}
if (strcmp (arg, "-l") == 0 || strcmp (arg, "--layer") == 0) {
if (++n == argc) {
print_usage (argv[0]);
return DFB_FALSE;
}
if (!parse_layer( argv[n] ))
return DFB_FALSE;
continue;
}
if (strcmp (arg, "-m") == 0 || strcmp (arg, "--mode") == 0) {
if (++n == argc) {
print_usage (argv[0]);
return DFB_FALSE;
}
if (!parse_mode( argv[n] ))
return DFB_FALSE;
continue;
}
if (strcmp (arg, "-f") == 0 || strcmp (arg, "--format") == 0) {
if (++n == argc) {
print_usage (argv[0]);
return DFB_FALSE;
}
if (!parse_format( argv[n] ))
return DFB_FALSE;
continue;
}
if (strcmp (arg, "-b") == 0 || strcmp (arg, "--buffer") == 0) {
if (++n == argc) {
print_usage (argv[0]);
return DFB_FALSE;
}
if (!parse_buffermode( argv[n] ))
return DFB_FALSE;
continue;
}
if (strcmp (arg, "-o") == 0 || strcmp (arg, "--opacity") == 0) {
if (++n == argc) {
print_usage (argv[0]);
return DFB_FALSE;
}
if (!parse_opacity( argv[n] ))
return DFB_FALSE;
continue;
}
if (strcmp (arg, "-L") == 0 || strcmp (arg, "--level") == 0) {
if (++n == argc) {
print_usage (argv[0]);
return DFB_FALSE;
}
if (!parse_level( argv[n] ))
return DFB_FALSE;
continue;
}
if (strcmp (arg, "-R") == 0 || strcmp (arg, "--rotate") == 0) {
if (++n == argc) {
print_usage (argv[0]);
return DFB_FALSE;
}
if (!parse_rotation( argv[n] ))
return DFB_FALSE;
continue;
}
if (strcmp (arg, "-t") == 0 || strcmp (arg, "--test-lock") == 0) {
test_lock = DSLF_READ | DSLF_WRITE;
continue;
}
if (strcmp (arg, "-tr") == 0 || strcmp (arg, "--test-lock-read") == 0) {
test_lock = DSLF_READ;
continue;
}
if (strcmp (arg, "-tw") == 0 || strcmp (arg, "--test-lock-write") == 0) {
test_lock = DSLF_WRITE;
continue;
}
print_usage (argv[0]);
return DFB_FALSE;
}
return DFB_TRUE;
}
