static void test_fail_read_flush(CuTest *tc)
{
apr_file_t *f;
const char *fname = "data/testflush.dat";
apr_status_t rv;
char buf[2];
apr_file_remove(fname, p);
apr_assert_success(tc, "open test file",
apr_file_open(&f, fname,
APR_CREATE|APR_READ|APR_BUFFERED,
APR_UREAD|APR_UWRITE, p));
/* this write should be buffered. */
apr_assert_success(tc, "buffered write should succeed",
apr_file_puts("hello", f));
/* Now, trying a read should fail since the write must be flushed,
* and should fail with something other than EOF since the file is
* opened read-only. */
rv = apr_file_read_full(f, buf, 2, NULL);
CuAssert(tc, "read should flush buffered write and fail",
rv != APR_SUCCESS && rv != APR_EOF);
/* Likewise for gets */
rv = apr_file_gets(buf, 2, f);
CuAssert(tc, "gets should flush buffered write and fail",
rv != APR_SUCCESS && rv != APR_EOF);
apr_file_close(f);
apr_file_remove(fname, p);
}
static char* libswitch_parseConfigFile(apr_pool_t* p, const char* conf, Config* config) {
apr_file_t* file=NULL;;
apr_status_t status;
char line[128];
char* comment;
char* command, *arg;
char **tokens;
int i, len;
status = apr_file_open (&file, conf, APR_READ,APR_OS_DEFAULT,p);
if(status!=APR_SUCCESS) {
return apr_pstrdup(p, "Unable to open config file");
}
memset(line,'\0',sizeof(line));
while((status=apr_file_gets (line,sizeof(line),file))==APR_SUCCESS){
char* cpy = astru_getTrimmedStr(p,line);
if(cpy!=NULL&&*cpy!='#') {
char* value = apr_strtok(cpy, "#", &comment);
apr_tokenize_to_argv(value, &tokens, p);
libswitch_runCommandHandler(p, config, tokens[0], tokens[1]);
}
}
apr_file_close ( file );
return NULL;
}
static int get_ldap_host(void)
{
apr_status_t rv;
apr_file_t *thefile = NULL;
char *ptr;
ldap_host[0] = '\0';
rv = apr_file_open(&thefile, FILENAME,
APR_FOPEN_READ,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
if (rv != APR_SUCCESS) {
return 0;
}
rv = apr_file_gets(ldap_host, sizeof(ldap_host), thefile);
if (rv != APR_SUCCESS) {
return 0;
}
ptr = strstr (ldap_host, "\r\n");
if (ptr) {
*ptr = '\0';
}
apr_file_close(thefile);
return 1;
}
static apr_status_t read_array(request_rec *r, apr_array_header_t* arr,
apr_file_t *file)
{
char w[MAX_STRING_LEN];
int p;
apr_status_t rv;
while (1) {
rv = apr_file_gets(w, MAX_STRING_LEN - 1, file);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"Premature end of vary array.");
return rv;
}
p = strlen(w);
if (p > 0 && w[p - 1] == '\n') {
if (p > 1 && w[p - 2] == CR) {
w[p - 2] = '\0';
}
else {
w[p - 1] = '\0';
}
}
/* If we've finished reading the array, break out of the loop. */
if (w[0] == '\0') {
break;
}
*((const char **) apr_array_push(arr)) = apr_pstrdup(r->pool, w);
}
return APR_SUCCESS;
}
dynalogin_result_t dynalogin_read_config_from_file(apr_hash_t **config,
const char *filename, apr_pool_t *pool)
{
apr_hash_t *_config = NULL;
apr_status_t res;
apr_file_t *f;
char buf[CFG_LINEBUF_LEN + 1];
size_t len;
int i;
char *key, *val;
*config = NULL;
if((_config=apr_hash_make(pool)) == NULL)
return DYNALOGIN_ERROR;
if(res=apr_file_open(&f, filename, APR_READ | APR_SHARELOCK, 0, pool)
!= APR_SUCCESS)
return DYNALOGIN_ERROR;
while(apr_file_gets(buf, CFG_LINEBUF_LEN, f) == APR_SUCCESS)
{
len = strlen(buf);
if(len > 0 && buf[len-1]=='\n')
buf[--len] = 0;
/* Lines starting with ; or # are comments, ignore them */
if(buf[0] == ';' || buf[0] == '#')
continue;
for(i = 0; i < len && buf[i] != '='; i++);
if(buf[i] == '=' && i > 0)
{
buf[i] = 0;
if((val = apr_pstrdup(pool, &buf[i+1])) == NULL)
{
apr_file_close(f);
return DYNALOGIN_ERROR;
}
if((key = apr_pstrdup(pool, buf))==NULL)
{
apr_file_close(f);
return DYNALOGIN_ERROR;
}
apr_hash_set(_config, key, APR_HASH_KEY_STRING, val);
}
}
apr_file_close(f);
*config = _config;
return DYNALOGIN_SUCCESS;
}
static apr_status_t fortune_process(conn_rec *c,
apr_procattr_t *pattr,
apr_bucket_brigade *bb)
{
apr_status_t rv;
int argc = 0;
const char *argv[APP_MAX_ARGC];
apr_proc_t proc;
apr_bucket *b;
apr_pool_t *p = c->pool;
fortune_conf_t *fconf = ap_get_module_config(c->base_server->module_config,
&fortune_module);
argv[argc++] = fconf->progname;
argv[argc++] = NULL; /* @argvs should be null-terminated */
if ((rv = apr_proc_create(&proc, fconf->progname,
(const char *const *) argv,
NULL, (apr_procattr_t *) pattr,
p)) != APR_SUCCESS) {
return rv;
}
while (TRUE) {
char buf[BUFSIZE] = { 0, };
/* read the command's output through the pipe */
rv = apr_file_gets(buf, sizeof(buf), proc.out);
if (APR_STATUS_IS_EOF(rv)) {
break;
}
b = apr_bucket_pool_create(apr_pstrdup(p, buf),
strlen(buf), p, c->bucket_alloc);
APR_BRIGADE_INSERT_TAIL(bb, b);
}
apr_file_close(proc.out);
{
int st;
apr_exit_why_e why;
rv = apr_proc_wait(&proc, &st, &why, APR_WAIT);
if (APR_STATUS_IS_CHILD_DONE(rv)) {
ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, c,
"child done: why = %d, exit status = %d", why, st);
}
else {
ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, c, "child notdone");
return APR_EGENERAL;
}
}
return APR_SUCCESS;
}
static void test_gets(CuTest *tc)
{
apr_file_t *f = NULL;
apr_status_t rv;
char *str = apr_palloc(p, 256);
rv = apr_file_open(&f, FILENAME, APR_READ, 0, p);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
rv = apr_file_gets(str, 256, f);
/* Only one line in the test file, so APR will encounter EOF on the first
* call to gets, but we should get APR_SUCCESS on this call and
* APR_EOF on the next.
*/
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertStrEquals(tc, TESTSTR, str);
rv = apr_file_gets(str, 256, f);
CuAssertIntEquals(tc, APR_EOF, rv);
CuAssertStrEquals(tc, "", str);
apr_file_close(f);
}
static void test_gets(abts_case *tc, void *data)
{
apr_file_t *f = NULL;
apr_status_t rv;
char *str = apr_palloc(p, 256);
rv = apr_file_open(&f, FILENAME, APR_READ, 0, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_gets(str, 256, f);
/* Only one line in the test file, so APR will encounter EOF on the first
* call to gets, but we should get APR_SUCCESS on this call and
* APR_EOF on the next.
*/
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, TESTSTR, str);
rv = apr_file_gets(str, 256, f);
ABTS_INT_EQUAL(tc, APR_EOF, rv);
ABTS_STR_EQUAL(tc, "", str);
apr_file_close(f);
}
/** Returns the name of the currently executing program.
*
* Allocates the result on pool.
*/
char *get_self_name(apr_pool_t *pool) {
apr_file_t *f;
apr_pool_t *subpool;
apr_status_t err;
char *self_name;
char line_buf[8096];
apr_pool_create(&subpool, pool);
err = apr_file_open(&f, "/proc/self/status", APR_READ, APR_OS_DEFAULT, subpool);
if (err != APR_SUCCESS) {
apr_pool_destroy(subpool);
return NULL;
}
while (1) {
char *s;
size_t line_s;
/* Read a line of the file. */
err = apr_file_gets(line_buf, sizeof(line_buf), f);
if (err != APR_SUCCESS)
break;
line_s = strlen(line_buf);
line_buf[--line_s] = '\0';
/* Search for the process name in the current line. */
s = strstr(line_buf, "Name:\t");
if (s != NULL) {
/* Go past the space. */
s += 6;
line_s -= 6;
if (line_s > 0) {
/* We have something, yay! As the memory was
allocated by read_line, we expect the returned
string to be sanely null-terminated. */
apr_pool_destroy(subpool);
self_name = apr_pstrdup(pool, s);
return self_name;
}
}
}
apr_pool_destroy(subpool);
return NULL;
}
/* Soak up stderr from a script and redirect it to the error log.
*/
static apr_status_t log_script_err(request_rec *r, apr_file_t *script_err)
{
char argsbuffer[HUGE_STRING_LEN];
char *newline;
apr_status_t rv;
while ((rv = apr_file_gets(argsbuffer, HUGE_STRING_LEN,
script_err)) == APR_SUCCESS) {
newline = strchr(argsbuffer, '\n');
if (newline) {
*newline = '\0';
}
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"%s", argsbuffer);
}
return rv;
}
/* Soak up stderr from a script and redirect it to the error log.
*/
static apr_status_t log_script_err(request_rec *r, apr_file_t *script_err)
{
char argsbuffer[HUGE_STRING_LEN];
char *newline;
apr_status_t rv;
cgi_server_conf *conf = ap_get_module_config(r->server->module_config, &cgi_module);
while ((rv = apr_file_gets(argsbuffer, HUGE_STRING_LEN,
script_err)) == APR_SUCCESS) {
newline = strchr(argsbuffer, '\n');
if (newline) {
*newline = '\0';
}
log_scripterror(r, conf, r->status, 0, APLOGNO(01215), argsbuffer);
}
return rv;
}
static void test_fail_read_flush(abts_case *tc, void *data)
{
apr_file_t *f;
const char *fname = "data/testflush.dat";
apr_status_t rv;
char buf[2];
apr_file_remove(fname, p);
APR_ASSERT_SUCCESS(tc, "open test file",
apr_file_open(&f, fname,
APR_CREATE|APR_READ|APR_BUFFERED,
APR_UREAD|APR_UWRITE, p));
/* this write should be buffered. */
APR_ASSERT_SUCCESS(tc, "buffered write should succeed",
apr_file_puts("hello", f));
/* Now, trying a read should fail since the write must be flushed,
* and should fail with something other than EOF since the file is
* opened read-only. */
rv = apr_file_read_full(f, buf, 2, NULL);
ABTS_ASSERT(tc, "read should flush buffered write and fail",
rv != APR_SUCCESS && rv != APR_EOF);
/* Likewise for gets */
rv = apr_file_gets(buf, 2, f);
ABTS_ASSERT(tc, "gets should flush buffered write and fail",
rv != APR_SUCCESS && rv != APR_EOF);
/* Likewise for seek. */
{
apr_off_t offset = 0;
rv = apr_file_seek(f, APR_SET, &offset);
}
ABTS_ASSERT(tc, "seek should flush buffered write and fail",
rv != APR_SUCCESS && rv != APR_EOF);
apr_file_close(f);
}
static apr_status_t mime_static_html_send_error_document(request_rec * r,
const char *path)
{
apr_status_t status;
apr_finfo_t finfo;
apr_file_t *fd = NULL;
conn_rec *c = r->connection;
apr_bucket_brigade *bb;
apr_bucket *e;
char buffer[4096];
/* ファイルがあるかどうか */
status = apr_stat(&finfo, path, APR_FINFO_TYPE, r->pool);
if (APR_SUCCESS != status) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r,
"AddMIMEStatic '%s'", path);
return APR_ENOSTAT;
}
/* 通常ファイル以外 .. ディレクトリなんぞを指定した場合 */
if (APR_REG != finfo.filetype) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"mod_mime_static_html.c Attempt to serve non regular file: %s",
path);
return APR_EGENERAL;
}
/* ファイルオープン */
status = apr_file_open(&fd, path, APR_READ, 0, r->pool);
if (APR_SUCCESS != status) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r,
"mod_mime_static_html.c file permissions deny server access: %s",
r->filename);
return APR_EGENERAL;
}
r->content_type = "text/html";
while (apr_file_gets(buffer, sizeof(buffer), fd) == APR_SUCCESS) {
ap_rprintf(r, "%s", buffer);
}
return APR_SUCCESS;
}
/** Read the master job pid from file on disc. */
static int
trell_get_master_pid( trell_sconf_t* svr_conf, request_rec* r, pid_t* pid )
{
apr_status_t rv;
apr_file_t* pidfile = NULL;
rv = apr_file_open( &pidfile, master_job_pidfile_path,
APR_READ, APR_OS_DEFAULT, r->pool );
if( rv != APR_SUCCESS ) {
ap_log_rerror( APLOG_MARK, APLOG_NOTICE, rv, r, "mod_trell: Failed to open master job pid file for reading." );
return rv;
}
char* line = (char*)apr_palloc( r->pool, sizeof(unsigned char)*256 );
rv = apr_file_gets( line, 256, pidfile );
if( rv != APR_SUCCESS ) {
ap_log_rerror( APLOG_MARK, APLOG_NOTICE, rv, r, "mod_trell: %s@%d", __FILE__, __LINE__ );
return rv;
}
*pid = apr_atoi64( line );
return APR_SUCCESS;
}
// Same as apr_helper_file_gets, but new line is stripped from line end
apr_status_t apr_helper_file_gets(char* str, size_t size, apr_file_t* thefile)
{
apr_status_t rv = APR_INCOMPLETE;
static char buf[1024];
memset(buf, 0, 1024);
try {
rv = apr_file_gets(buf, 1024, thefile);
if (rv == APR_SUCCESS)
{
size_t str_len = strlen(buf);
size_t dst_len = str_len + 1;
if ((strstr(buf, LFCR) != NULL) || (strstr(buf, CRLF) != NULL))
{
dst_len -= 2;
}
else if (strstr(buf, LF) != NULL)
{
dst_len -= 1;
}
if (dst_len > size)
{
dst_len = size;
}
apr_cpystrn(str, buf, dst_len);
rv = APR_SUCCESS;
}
else
{
rv = APR_EGENERAL;
}
}
catch (std::bad_alloc&) {
rv = APR_EGENERAL;
}
return rv;
}
//-----------------------------------------------------------------------------
// loadMotions()
//-----------------------------------------------------------------------------
BOOL LLKeyframeMotionParam::loadMotions()
{
//-------------------------------------------------------------------------
// Load named file by concatenating the character prefix with the motion name.
// Load data into a buffer to be parsed.
//-------------------------------------------------------------------------
std::string path = gDirUtilp->getExpandedFilename(LL_PATH_MOTIONS,mCharacter->getAnimationPrefix())
+ "_" + getName() + ".llp";
//-------------------------------------------------------------------------
// open the file
//-------------------------------------------------------------------------
S32 fileSize = 0;
LLAPRFile infile ;
infile.open(path, LL_APR_R, NULL, &fileSize);
apr_file_t* fp = infile.getFileHandle() ;
if (!fp || fileSize == 0)
{
llinfos << "ERROR: can't open: " << path << llendl;
return FALSE;
}
// allocate a text buffer
char *text = new char[ fileSize+1 ];
if ( !text )
{
llinfos << "ERROR: can't allocated keyframe text buffer." << llendl;
return FALSE;
}
//-------------------------------------------------------------------------
// load data from file into buffer
//-------------------------------------------------------------------------
bool error = false;
char *p = text;
while ( 1 )
{
if (apr_file_eof(fp) == APR_EOF)
{
break;
}
if (apr_file_gets(p, 1024, fp) != APR_SUCCESS)
{
error = true;
break;
}
while ( *(++p) )
;
}
//-------------------------------------------------------------------------
// close the file
//-------------------------------------------------------------------------
infile.close();
//-------------------------------------------------------------------------
// check for error
//-------------------------------------------------------------------------
llassert( p <= (text+fileSize) );
if ( error )
{
llinfos << "ERROR: error while reading from " << path << llendl;
delete [] text;
return FALSE;
}
llinfos << "Loading parametric keyframe data for: " << getName() << llendl;
//-------------------------------------------------------------------------
// parse the text and build keyframe data structures
//-------------------------------------------------------------------------
p = text;
S32 num;
char strA[80]; /* Flawfinder: ignore */
char strB[80]; /* Flawfinder: ignore */
F32 floatA = 0.0f;
//-------------------------------------------------------------------------
// get priority
//-------------------------------------------------------------------------
BOOL isFirstMotion = TRUE;
num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */
while(1)
{
if (num == 0 || num == EOF) break;
if ((num != 3))
{
llinfos << "WARNING: can't read parametric motion" << llendl;
delete [] text;
return FALSE;
}
addKeyframeMotion(strA, gAnimLibrary.stringToAnimState(std::string(strA)), strB, floatA);
if (isFirstMotion)
{
isFirstMotion = FALSE;
setDefaultKeyframeMotion(strA);
}
p = strstr(p, "\n");
if (!p)
{
break;
}
p++;
num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */
}
delete [] text;
return TRUE;
}
/* This is a horrible name for this function. We are testing APR, not how
* Apache uses APR. And, this function tests _way_ too much stuff.
*/
static void test_mod_neg(abts_case *tc, void *data)
{
apr_status_t rv;
apr_file_t *f;
const char *s;
int i;
apr_size_t nbytes;
char buf[8192];
apr_off_t cur;
const char *fname = "data/modneg.dat";
rv = apr_file_open(&f, fname,
APR_CREATE | APR_WRITE, APR_UREAD | APR_UWRITE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
s = "body56789\n";
nbytes = strlen(s);
rv = apr_file_write(f, s, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, strlen(s), nbytes);
for (i = 0; i < 7980; i++) {
s = "0";
nbytes = strlen(s);
rv = apr_file_write(f, s, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, strlen(s), nbytes);
}
s = "end456789\n";
nbytes = strlen(s);
rv = apr_file_write(f, s, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, strlen(s), nbytes);
for (i = 0; i < 10000; i++) {
s = "1";
nbytes = strlen(s);
rv = apr_file_write(f, s, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, strlen(s), nbytes);
}
rv = apr_file_close(f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_open(&f, fname, APR_READ, 0, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_gets(buf, 11, f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "body56789\n", buf);
cur = 0;
rv = apr_file_seek(f, APR_CUR, &cur);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_ASSERT(tc, "File Pointer Mismatch, expected 10", cur == 10);
nbytes = sizeof(buf);
rv = apr_file_read(f, buf, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, nbytes, sizeof(buf));
cur = -((apr_off_t)nbytes - 7980);
rv = apr_file_seek(f, APR_CUR, &cur);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_ASSERT(tc, "File Pointer Mismatch, expected 7990", cur == 7990);
rv = apr_file_gets(buf, 11, f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "end456789\n", buf);
rv = apr_file_close(f);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_remove(fname, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
static apr_status_t read_table(cache_handle_t *handle, request_rec *r,
apr_table_t *table, apr_file_t *file)
{
char w[MAX_STRING_LEN];
char *l;
int p;
apr_status_t rv;
while (1) {
/* ### What about APR_EOF? */
rv = apr_file_gets(w, MAX_STRING_LEN - 1, file);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"Premature end of cache headers.");
return rv;
}
/* Delete terminal (CR?)LF */
p = strlen(w);
/* Indeed, the host's '\n':
'\012' for UNIX; '\015' for MacOS; '\025' for OS/390
-- whatever the script generates.
*/
if (p > 0 && w[p - 1] == '\n') {
if (p > 1 && w[p - 2] == CR) {
w[p - 2] = '\0';
}
else {
w[p - 1] = '\0';
}
}
/* If we've finished reading the headers, break out of the loop. */
if (w[0] == '\0') {
break;
}
#if APR_CHARSET_EBCDIC
/* Chances are that we received an ASCII header text instead of
* the expected EBCDIC header lines. Try to auto-detect:
*/
if (!(l = strchr(w, ':'))) {
int maybeASCII = 0, maybeEBCDIC = 0;
unsigned char *cp, native;
apr_size_t inbytes_left, outbytes_left;
for (cp = w; *cp != '\0'; ++cp) {
native = apr_xlate_conv_byte(ap_hdrs_from_ascii, *cp);
if (apr_isprint(*cp) && !apr_isprint(native))
++maybeEBCDIC;
if (!apr_isprint(*cp) && apr_isprint(native))
++maybeASCII;
}
if (maybeASCII > maybeEBCDIC) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
"CGI Interface Error: Script headers apparently ASCII: (CGI = %s)",
r->filename);
inbytes_left = outbytes_left = cp - w;
apr_xlate_conv_buffer(ap_hdrs_from_ascii,
w, &inbytes_left, w, &outbytes_left);
}
}
#endif /*APR_CHARSET_EBCDIC*/
/* if we see a bogus header don't ignore it. Shout and scream */
if (!(l = strchr(w, ':'))) {
return APR_EGENERAL;
}
*l++ = '\0';
while (*l && apr_isspace(*l)) {
++l;
}
apr_table_add(table, w, l);
}
return APR_SUCCESS;
}
// writes the group data to a buffer and then attempts to match it against a
// regular expression
static void get_groups(request_rec *r, apr_file_t* groups_data, char **groups) {
char temp[MAX_DATA_SIZE];
apr_status_t rv;
rv = apr_file_gets(temp, MAX_DATA_SIZE, groups_data);
*groups = match_and_process_expression(r, temp, GROUPS_NUM_GROUPS, REGEXP_GROUP_SIZE, GROUPS_REG_EXP, extract_groups_data);
}
// this function writes the user data and then attempts to match it against a
// regular expression
static void get_user(request_rec *r, apr_file_t* user_data, char **user) {
char temp[MAX_DATA_SIZE];
apr_status_t rv;
rv = apr_file_gets(temp, MAX_DATA_SIZE, user_data);
*user = match_and_process_expression(r, temp, USER_NUM_GROUPS, REGEXP_GROUP_SIZE, USER_REG_EXP, extract_user_data);
}
static apr_status_t to_dbm(apr_dbm_t *dbm, apr_file_t *fp, apr_pool_t *pool)
{
apr_status_t rv = APR_SUCCESS;
char line[REWRITE_MAX_TXT_MAP_LINE + 1]; /* +1 for \0 */
apr_datum_t dbmkey;
apr_datum_t dbmval;
apr_pool_t* p;
apr_pool_create(&p, pool);
while (apr_file_gets(line, sizeof(line), fp) == APR_SUCCESS) {
char *c, *value;
if (*line == '#' || apr_isspace(*line)) {
continue;
}
c = line;
while (*c && !apr_isspace(*c)) {
++c;
}
if (!*c) {
/* no value. solid line of data. */
continue;
}
dbmkey.dptr = apr_pstrmemdup(p, line, c - line);
dbmkey.dsize = (c - line);
while (*c && apr_isspace(*c)) {
++c;
}
if (!*c) {
apr_pool_clear(p);
continue;
}
value = c;
while (*c && !apr_isspace(*c)) {
++c;
}
dbmval.dptr = apr_pstrmemdup(p, value, c - value);
dbmval.dsize = (c - line);
if (verbose) {
apr_file_printf(errfile, " '%s' -> '%s'"NL,
dbmkey.dptr, dbmval.dptr);
}
rv = apr_dbm_store(dbm, dbmkey, dbmval);
apr_pool_clear(p);
if (rv != APR_SUCCESS) {
break;
}
}
return rv;
}
/*
* Let's do it. We end up doing a lot of file opening and closing,
* but what do we care? This application isn't run constantly.
*/
int main(int argc, const char * const argv[])
{
apr_file_t *fpw = NULL;
char record[MAX_STRING_LEN];
char line[MAX_STRING_LEN];
char *password = NULL;
char *pwfilename = NULL;
char *user = NULL;
char tn[] = "htpasswd.tmp.XXXXXX";
char *dirname;
char *scratch, cp[MAX_STRING_LEN];
int found = 0;
int i;
int alg = ALG_APMD5;
int mask = 0;
apr_pool_t *pool;
int existing_file = 0;
#if APR_CHARSET_EBCDIC
apr_status_t rv;
apr_xlate_t *to_ascii;
#endif
apr_app_initialize(&argc, &argv, NULL);
atexit(terminate);
apr_pool_create(&pool, NULL);
apr_file_open_stderr(&errfile, pool);
#if APR_CHARSET_EBCDIC
rv = apr_xlate_open(&to_ascii, "ISO-8859-1", APR_DEFAULT_CHARSET, pool);
if (rv) {
apr_file_printf(errfile, "apr_xlate_open(to ASCII)->%d" NL, rv);
exit(1);
}
rv = apr_SHA1InitEBCDIC(to_ascii);
if (rv) {
apr_file_printf(errfile, "apr_SHA1InitEBCDIC()->%d" NL, rv);
exit(1);
}
rv = apr_MD5InitEBCDIC(to_ascii);
if (rv) {
apr_file_printf(errfile, "apr_MD5InitEBCDIC()->%d" NL, rv);
exit(1);
}
#endif /*APR_CHARSET_EBCDIC*/
check_args(pool, argc, argv, &alg, &mask, &user, &pwfilename, &password);
#if defined(WIN32) || defined(NETWARE)
if (alg == ALG_CRYPT) {
alg = ALG_APMD5;
apr_file_printf(errfile, "Automatically using MD5 format." NL);
}
#endif
#if (!(defined(WIN32) || defined(TPF) || defined(NETWARE)))
if (alg == ALG_PLAIN) {
apr_file_printf(errfile,"Warning: storing passwords as plain text "
"might just not work on this platform." NL);
}
#endif
/*
* Only do the file checks if we're supposed to frob it.
*/
if (!(mask & APHTP_NOFILE)) {
existing_file = exists(pwfilename, pool);
if (existing_file) {
/*
* Check that this existing file is readable and writable.
*/
if (!accessible(pool, pwfilename, APR_READ | APR_APPEND)) {
apr_file_printf(errfile, "%s: cannot open file %s for "
"read/write access" NL, argv[0], pwfilename);
exit(ERR_FILEPERM);
}
}
else {
/*
* Error out if -c was omitted for this non-existant file.
*/
if (!(mask & APHTP_NEWFILE)) {
apr_file_printf(errfile,
"%s: cannot modify file %s; use '-c' to create it" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
/*
* As it doesn't exist yet, verify that we can create it.
*/
if (!accessible(pool, pwfilename, APR_CREATE | APR_WRITE)) {
apr_file_printf(errfile, "%s: cannot create file %s" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
}
}
/*
* All the file access checks (if any) have been made. Time to go to work;
* try to create the record for the username in question. If that
* fails, there's no need to waste any time on file manipulations.
* Any error message text is returned in the record buffer, since
* the mkrecord() routine doesn't have access to argv[].
*/
if (!(mask & APHTP_DELUSER)) {
i = mkrecord(user, record, sizeof(record) - 1,
password, alg);
if (i != 0) {
apr_file_printf(errfile, "%s: %s" NL, argv[0], record);
exit(i);
}
if (mask & APHTP_NOFILE) {
printf("%s" NL, record);
exit(0);
}
}
/*
* We can access the files the right way, and we have a record
* to add or update. Let's do it..
*/
if (apr_temp_dir_get((const char**)&dirname, pool) != APR_SUCCESS) {
apr_file_printf(errfile, "%s: could not determine temp dir" NL,
argv[0]);
exit(ERR_FILEPERM);
}
dirname = apr_psprintf(pool, "%s/%s", dirname, tn);
if (apr_file_mktemp(&ftemp, dirname, 0, pool) != APR_SUCCESS) {
apr_file_printf(errfile, "%s: unable to create temporary file %s" NL,
argv[0], dirname);
exit(ERR_FILEPERM);
}
/*
* If we're not creating a new file, copy records from the existing
* one to the temporary file until we find the specified user.
*/
if (existing_file && !(mask & APHTP_NEWFILE)) {
if (apr_file_open(&fpw, pwfilename, APR_READ | APR_BUFFERED,
APR_OS_DEFAULT, pool) != APR_SUCCESS) {
apr_file_printf(errfile, "%s: unable to read file %s" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
while (apr_file_gets(line, sizeof(line), fpw) == APR_SUCCESS) {
char *colon;
strcpy(cp, line);
scratch = cp;
while (apr_isspace(*scratch)) {
++scratch;
}
if (!*scratch || (*scratch == '#')) {
putline(ftemp, line);
continue;
}
/*
* See if this is our user.
*/
colon = strchr(scratch, ':');
if (colon != NULL) {
*colon = '\0';
}
else {
/*
* If we've not got a colon on the line, this could well
* not be a valid htpasswd file.
* We should bail at this point.
*/
apr_file_printf(errfile, "%s: The file %s does not appear "
"to be a valid htpasswd file." NL,
argv[0], pwfilename);
apr_file_close(fpw);
exit(ERR_INVALID);
}
if (strcmp(user, scratch) != 0) {
putline(ftemp, line);
continue;
}
else {
if (!(mask & APHTP_DELUSER)) {
/* We found the user we were looking for.
* Add him to the file.
*/
apr_file_printf(errfile, "Updating ");
putline(ftemp, record);
found++;
}
else {
/* We found the user we were looking for.
* Delete them from the file.
*/
apr_file_printf(errfile, "Deleting ");
found++;
}
}
}
apr_file_close(fpw);
}
if (!found && !(mask & APHTP_DELUSER)) {
apr_file_printf(errfile, "Adding ");
putline(ftemp, record);
}
else if (!found && (mask & APHTP_DELUSER)) {
apr_file_printf(errfile, "User %s not found" NL, user);
exit(0);
}
apr_file_printf(errfile, "password for user %s" NL, user);
/* The temporary file has all the data, just copy it to the new location.
*/
if (apr_file_copy(dirname, pwfilename, APR_FILE_SOURCE_PERMS, pool) !=
APR_SUCCESS) {
apr_file_printf(errfile, "%s: unable to update file %s" NL,
argv[0], pwfilename);
exit(ERR_FILEPERM);
}
apr_file_close(ftemp);
return 0;
}
static int log_script(request_rec *r, cgi_server_conf * conf, int ret,
char *dbuf, const char *sbuf, apr_bucket_brigade *bb,
apr_file_t *script_err)
{
const apr_array_header_t *hdrs_arr = apr_table_elts(r->headers_in);
const apr_table_entry_t *hdrs = (const apr_table_entry_t *) hdrs_arr->elts;
char argsbuffer[HUGE_STRING_LEN];
apr_file_t *f = NULL;
apr_bucket *e;
const char *buf;
apr_size_t len;
apr_status_t rv;
int first;
int i;
apr_finfo_t finfo;
char time_str[APR_CTIME_LEN];
/* XXX Very expensive mainline case! Open, then getfileinfo! */
if (!conf->logname ||
((apr_stat(&finfo, conf->logname,
APR_FINFO_SIZE, r->pool) == APR_SUCCESS) &&
(finfo.size > conf->logbytes)) ||
(apr_file_open(&f, conf->logname,
APR_APPEND|APR_WRITE|APR_CREATE, APR_OS_DEFAULT,
r->pool) != APR_SUCCESS)) {
/* Soak up script output */
discard_script_output(bb);
log_script_err(r, script_err);
return ret;
}
/* "%% [Wed Jun 19 10:53:21 1996] GET /cgi-bin/printenv HTTP/1.0" */
apr_ctime(time_str, apr_time_now());
apr_file_printf(f, "%%%% [%s] %s %s%s%s %s\n", time_str, r->method, r->uri,
r->args ? "?" : "", r->args ? r->args : "", r->protocol);
/* "%% 500 /usr/local/apache/cgi-bin" */
apr_file_printf(f, "%%%% %d %s\n", ret, r->filename);
apr_file_puts("%request\n", f);
for (i = 0; i < hdrs_arr->nelts; ++i) {
if (!hdrs[i].key)
continue;
apr_file_printf(f, "%s: %s\n", hdrs[i].key, hdrs[i].val);
}
if ((r->method_number == M_POST || r->method_number == M_PUT) &&
*dbuf) {
apr_file_printf(f, "\n%s\n", dbuf);
}
apr_file_puts("%response\n", f);
hdrs_arr = apr_table_elts(r->err_headers_out);
hdrs = (const apr_table_entry_t *) hdrs_arr->elts;
for (i = 0; i < hdrs_arr->nelts; ++i) {
if (!hdrs[i].key)
continue;
apr_file_printf(f, "%s: %s\n", hdrs[i].key, hdrs[i].val);
}
if (sbuf && *sbuf)
apr_file_printf(f, "%s\n", sbuf);
first = 1;
for (e = APR_BRIGADE_FIRST(bb);
e != APR_BRIGADE_SENTINEL(bb);
e = APR_BUCKET_NEXT(e))
{
if (APR_BUCKET_IS_EOS(e)) {
break;
}
rv = apr_bucket_read(e, &buf, &len, APR_BLOCK_READ);
if (rv != APR_SUCCESS || (len == 0)) {
break;
}
if (first) {
apr_file_puts("%stdout\n", f);
first = 0;
}
apr_file_write(f, buf, &len);
apr_file_puts("\n", f);
}
if (apr_file_gets(argsbuffer, HUGE_STRING_LEN, script_err) == APR_SUCCESS) {
apr_file_puts("%stderr\n", f);
apr_file_puts(argsbuffer, f);
while (apr_file_gets(argsbuffer, HUGE_STRING_LEN,
script_err) == APR_SUCCESS) {
apr_file_puts(argsbuffer, f);
}
apr_file_puts("\n", f);
}
apr_brigade_destroy(bb);
apr_file_close(script_err);
apr_file_close(f);
return ret;
}
//-----------------------------------------------------------------------------
// loadMotions()
//-----------------------------------------------------------------------------
BOOL LLKeyframeMotionParam::loadMotions()
{
//-------------------------------------------------------------------------
// Load named file by concatenating the character prefix with the motion name.
// Load data into a buffer to be parsed.
//-------------------------------------------------------------------------
//std::string path = gDirUtilp->getExpandedFilename(LL_PATH_MOTIONS,mCharacter->getAnimationPrefix())
// + "_" + getName() + ".llp";
//RN: deprecated unused reference to "motion" directory
std::string path;
//-------------------------------------------------------------------------
// open the file
//-------------------------------------------------------------------------
S32 fileSize = 0;
LLAPRFile infile ;
infile.open(path, LL_APR_R, NULL, &fileSize);
// <FS:ND> Remove LLVolatileAPRPool/apr_file_t and use FILE* instead
// apr_file_t* fp = infile.getFileHandle() ;
LLAPRFile::tFiletype* fp = infile.getFileHandle() ;
// </FS:ND>
if (!fp || fileSize == 0)
{
LL_INFOS() << "ERROR: can't open: " << path << LL_ENDL;
return FALSE;
}
// allocate a text buffer
std::vector<char> text(fileSize+1);
//-------------------------------------------------------------------------
// load data from file into buffer
//-------------------------------------------------------------------------
bool error = false;
char *p = &text[0];
while ( 1 )
{
if (apr_file_eof(fp) == APR_EOF)
{
break;
}
if (apr_file_gets(p, 1024, fp) != APR_SUCCESS)
{
error = true;
break;
}
while ( *(++p) )
;
}
//-------------------------------------------------------------------------
// close the file
//-------------------------------------------------------------------------
infile.close();
//-------------------------------------------------------------------------
// check for error
//-------------------------------------------------------------------------
llassert( p <= (&text[0] + fileSize) );
if ( error )
{
LL_INFOS() << "ERROR: error while reading from " << path << LL_ENDL;
return FALSE;
}
LL_INFOS() << "Loading parametric keyframe data for: " << getName() << LL_ENDL;
//-------------------------------------------------------------------------
// parse the text and build keyframe data structures
//-------------------------------------------------------------------------
p = &text[0];
S32 num;
char strA[80]; /* Flawfinder: ignore */
char strB[80]; /* Flawfinder: ignore */
F32 floatA = 0.0f;
//-------------------------------------------------------------------------
// get priority
//-------------------------------------------------------------------------
BOOL isFirstMotion = TRUE;
num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */
while(1)
{
if (num == 0 || num == EOF) break;
if ((num != 3))
{
LL_INFOS() << "WARNING: can't read parametric motion" << LL_ENDL;
return FALSE;
}
addKeyframeMotion(strA, gAnimLibrary.stringToAnimState(std::string(strA)), strB, floatA);
if (isFirstMotion)
{
isFirstMotion = FALSE;
setDefaultKeyframeMotion(strA);
}
p = strstr(p, "\n");
if (!p)
{
break;
}
p++;
num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */
}
return TRUE;
}
static int getsfunc_FILE(char *buf, int len, void *f)
{
return apr_file_gets(buf, len, (apr_file_t *) f) == APR_SUCCESS;
}
static int kdkey_read_key_file(apr_pool_t *pool, apr_file_t *f, struct kdkey_info *ki) {
apr_status_t s;
char start[256];
char key_id_str[256];
char owner_str[256];
char key[256];
size_t sz;
kbuffer *key_buffer;
int r = -1;
ki->owner = NULL;
ki->owner_s = 0;
ki->data = NULL;
ki->data_s = 0;
do {
key_buffer = kbuffer_new();
s = apr_file_gets(start, sizeof(start), f);
if (s != APR_SUCCESS) {
KERROR_SET_APR(_keys_, 0, s);
break;
}
if (strcmp(start, start_sig_pkey) == 0)
ki->type = PKEY_SIGNATURE;
else if (strcmp(start, start_sig_skey) == 0)
ki->type = SKEY_SIGNATURE;
else if (strcmp(start, start_enc_pkey) == 0)
ki->type = PKEY_ENCRYPTION;
else if (strcmp(start, start_enc_skey) == 0)
ki->type = SKEY_ENCRYPTION;
else {
KERROR_SET(_kctl_, 1, "Incorrect key format. Unknown key type in %s.\n", start);
break;
}
/* Read the key ID. */
s = apr_file_gets(key_id_str, sizeof(key_id_str), f);
if (s != APR_SUCCESS) {
KERROR_SET_APR(_keys_, 0, s);
break;
}
/* Check the key number. */
if (sscanf(key_id_str, PRINTF_64"u", &ki->key_id) < 1) {
KERROR_SET(_kctl_, 1, "Invalid number: %s\n", key_id_str);
break;
}
/* Read the key owner. */
s = apr_file_gets(owner_str, sizeof(owner_str), f);
if (s != APR_SUCCESS) {
KERROR_SET_APR(_keys_, 0, s);
break;
}
sz = strlen(owner_str);
ki->owner = apr_pmemdup(pool, owner_str, sz - 1);
ki->owner_s = sz - 1;
/* Loop until we find the end delimiter, removing newlines on the
way. */
s = apr_file_gets(key, sizeof(key), f);
if (s != APR_SUCCESS) {
KERROR_SET_APR(_keys_, 0, s);
break;
}
do {
sz = strlen(key);
if (key[sz - 1] == '\n')
kbuffer_write(key_buffer, (uint8_t *)key, sz - 1);
else
kbuffer_write(key_buffer, (uint8_t *)key, sz);
s = apr_file_gets(key, sizeof(key), f);
if (s != APR_SUCCESS) {
KERROR_SET_APR(_keys_, 0, s);
break;
}
} while (strncmp(key, "---", 3) != 0);
/* Copy the content of the buffer. */
ki->data = apr_pmemdup(pool, key_buffer->data, key_buffer->len);
ki->data_s = key_buffer->len;
r = 0;
} while (0);
kbuffer_destroy(key_buffer);
/* We don't create the tagcrypt right now. */
ki->key = NULL;
return r;
}
