void ediDefineValidation(cchar *name, EdiValidationProc vfn)
{
EdiService *es;
es = MPR->ediService;
mprAddKey(es->validations, name, vfn);
}
/*
Add key/value to the header hash. If already present, update the value
*/
static void addHdr(HttpConn *conn, cchar *key, cchar *value)
{
assert(key && *key);
assert(value);
mprAddKey(conn->tx->headers, key, value);
}
PUBLIC void espDefineAction(HttpRoute *route, cchar *target, void *callback)
{
EspRoute *eroute;
char *action, *controller;
assert(route);
assert(target && *target);
assert(callback);
eroute = ((EspRoute*) route->eroute)->top;
if (target) {
#if DEPRECATED || 1
/*
Keep till version 6
*/
if (scontains(target, "-cmd-")) {
target = sreplace(target, "-cmd-", "/");
} else if (schr(target, '-')) {
controller = ssplit(sclone(target), "-", (char**) &action);
target = sjoin(controller, "/", action, NULL);
}
#endif
if (!eroute->actions) {
eroute->actions = mprCreateHash(-1, MPR_HASH_STATIC_VALUES);
}
mprAddKey(eroute->actions, target, callback);
}
}
static void testHashScale(MprTestGroup *gp)
{
MprHash *table;
MprKey *sp;
char *str;
char name[80], *address;
int i;
table = mprCreateHash(HASH_COUNT, 0);
assert(mprGetHashLength(table) == 0);
/*
All inserts below will insert allocated strings. We must free before
deleting the table.
*/
for (i = 0; i < HASH_COUNT; i++) {
mprSprintf(name, sizeof(name), "name.%d", i);
address = sfmt("%d Park Ave", i);
sp = mprAddKey(table, name, address);
assert(sp != 0);
}
assert(mprGetHashLength(table) == HASH_COUNT);
/*
Check data entered into the hash
*/
for (i = 0; i < HASH_COUNT; i++) {
mprSprintf(name, sizeof(name), "name.%d", i);
str = mprLookupKey(table, name);
assert(str != 0);
address = sfmt("%d Park Ave", i);
assert(strcmp(str, address) == 0);
}
}
void ediAddProvider(EdiProvider *provider)
{
EdiService *es;
es = MPR->ediService;
mprAddKey(es->providers, provider->name, provider);
}
/*
This clones a database to give a private view per user.
*/
static int cloneDatabase(HttpConn *conn)
{
Esp *esp;
EspRoute *eroute;
EspReq *req;
cchar *id;
req = conn->reqData;
eroute = conn->rx->route->eroute;
assert(eroute->edi);
assert(eroute->edi->flags & EDI_PRIVATE);
esp = req->esp;
if (!esp->databases) {
lock(esp);
if (!esp->databases) {
esp->databases = mprCreateHash(0, 0);
esp->databasesTimer = mprCreateTimerEvent(NULL, "esp-databases", 60 * 1000, pruneDatabases, esp, 0);
}
unlock(esp);
}
/*
If the user is logging in or out, this will create a redundant session here.
*/
httpGetSession(conn, 1);
id = httpGetSessionID(conn);
if ((req->edi = mprLookupKey(esp->databases, id)) == 0) {
if ((req->edi = ediClone(eroute->edi)) == 0) {
mprLog("error esp", 0, "Cannot clone database: %s", eroute->edi->path);
return MPR_ERR_CANT_OPEN;
}
mprAddKey(esp->databases, id, req->edi);
}
return 0;
}
int ejsAddConstant(Ejs *ejs, EjsModule *mp, cchar *str)
{
EjsConstants *cp;
ssize len, oldLen;
int index;
cp = mp->constants;
if (cp->locked) {
mprLog("ejs vm", 0, "Constant pool for module is locked. Cannot add constant \"%s\".", str);
return MPR_ERR_CANT_WRITE;
}
lock(mp);
len = slen(str) + 1;
if (ejsGrowConstants(ejs, mp, len) < 0) {
unlock(mp);
return MPR_ERR_MEMORY;
}
memcpy(&cp->pool[cp->poolLength], str, len);
oldLen = cp->poolLength;
cp->poolLength += len;
mprAddKey(cp->table, str, ITOP(cp->indexCount));
cp->index[cp->indexCount] = ITOP(oldLen << 1 | 1);
index = cp->indexCount++;
unlock(mp);
return index;
}
PUBLIC void espSetFeedbackv(HttpConn *conn, cchar *kind, cchar *fmt, va_list args)
{
EspReq *req;
cchar *prior, *msg;
req = conn->data;
msg = sfmtv(fmt, args);
if (req->feedback == 0) {
req->feedback = mprCreateHash(0, MPR_HASH_STABLE);
}
if ((prior = mprLookupKey(req->feedback, kind)) != 0) {
mprAddKey(req->feedback, kind, sjoin(prior, "\n", msg, NULL));
} else {
mprAddKey(req->feedback, kind, sclone(msg));
}
}
static void setupTrace(Ejs *ejs, HttpTrace *trace, int dir, EjsObj *options)
{
EjsArray *extensions;
EjsObj *ext;
HttpTrace *tp;
int i, level, *levels;
tp = &trace[dir];
levels = tp->levels;
if ((level = getNumOption(ejs, options, "all")) >= 0) {
for (i = 0; i < HTTP_TRACE_MAX_ITEM; i++) {
levels[i] = level;
}
} else {
levels[HTTP_TRACE_CONN] = getNumOption(ejs, options, "conn");
levels[HTTP_TRACE_FIRST] = getNumOption(ejs, options, "first");
levels[HTTP_TRACE_HEADER] = getNumOption(ejs, options, "headers");
levels[HTTP_TRACE_BODY] = getNumOption(ejs, options, "body");
}
tp->size = getNumOption(ejs, options, "size");
if ((extensions = (EjsArray*) ejsGetPropertyByName(ejs, options, EN("include"))) != 0) {
if (!ejsIs(ejs, extensions, Array)) {
ejsThrowArgError(ejs, "include is not an array");
return;
}
tp->include = mprCreateHash(0, 0);
for (i = 0; i < extensions->length; i++) {
if ((ext = ejsGetProperty(ejs, extensions, i)) != 0) {
mprAddKey(tp->include, ejsToMulti(ejs, ejsToString(ejs, ext)), "");
}
}
}
if ((extensions = (EjsArray*) ejsGetPropertyByName(ejs, options, EN("exclude"))) != 0) {
if (!ejsIs(ejs, extensions, Array)) {
ejsThrowArgError(ejs, "exclude is not an array");
return;
}
tp->exclude = mprCreateHash(0, 0);
for (i = 0; i < extensions->length; i++) {
if ((ext = ejsGetProperty(ejs, extensions, i)) != 0) {
mprAddKey(tp->exclude, ejsToMulti(ejs, ejsToString(ejs, ext)), MPR->emptyString);
}
}
}
}
/*
Parent may be null
*/
PUBLIC HttpTrace *httpCreateTrace(HttpTrace *parent)
{
HttpTrace *trace;
if ((trace = mprAllocObj(HttpTrace, manageTrace)) == 0) {
return 0;
}
if (parent) {
*trace = *parent;
trace->parent = parent;
} else {
if ((trace->events = mprCreateHash(0, MPR_HASH_STATIC_VALUES)) == 0) {
return 0;
}
mprAddKey(trace->events, "request", ITOP(1));
mprAddKey(trace->events, "result", ITOP(2));
mprAddKey(trace->events, "error", ITOP(2));
mprAddKey(trace->events, "context", ITOP(3));
mprAddKey(trace->events, "form", ITOP(4));
mprAddKey(trace->events, "body", ITOP(5));
mprAddKey(trace->events, "debug", ITOP(5));
trace->size = HTTP_TRACE_MAX_SIZE;
trace->formatter = httpDetailTraceFormatter;
trace->logger = httpWriteTraceLogFile;
trace->mutex = mprCreateLock();
}
return trace;
}
PUBLIC void espInitHtmlOptions(Esp *esp)
{
char **op;
esp->internalOptions = mprCreateHash(-1, MPR_HASH_STATIC_VALUES);
for (op = internalOptions; *op; op++) {
mprAddKey(esp->internalOptions, *op, op);
}
}
PUBLIC void httpDefineAction(cchar *name, HttpAction action)
{
HttpStage *stage;
if ((stage = httpLookupStage(MPR->httpService, "actionHandler")) == 0) {
mprError("Cannot find actionHandler");
return;
}
mprAddKey(stage->stageData, name, action);
}
PUBLIC void httpDefineAction(cchar *name, HttpAction action)
{
HttpStage *stage;
if ((stage = httpLookupStage("actionHandler")) == 0) {
mprLog("error http action", 0, "Cannot find actionHandler");
return;
}
mprAddKey(stage->stageData, name, action);
}
/*
Path should be an app-relative path to the view file (relative-path.esp)
*/
void espDefineView(HttpRoute *route, cchar *path, void *view)
{
Esp *esp;
mprAssert(path && *path);
mprAssert(view);
esp = MPR->espService;
path = mprGetPortablePath(mprJoinPath(route->dir, path));
mprAddKey(esp->views, path, view);
}
PUBLIC HttpRole *httpAddRole(HttpAuth *auth, cchar *name, cchar *abilities)
{
HttpRole *role;
char *ability, *tok;
GRADUATE_HASH(auth, roles);
if ((role = mprLookupKey(auth->roles, name)) == 0) {
if ((role = mprAllocObj(HttpRole, manageRole)) == 0) {
return 0;
}
role->name = sclone(name);
}
role->abilities = mprCreateHash(0, 0);
for (ability = stok(sclone(abilities), " \t", &tok); ability; ability = stok(NULL, " \t", &tok)) {
mprAddKey(role->abilities, ability, role);
}
if (mprAddKey(auth->roles, name, role) == 0) {
return 0;
}
return role;
}
PUBLIC void espSetFlashv(HttpConn *conn, cchar *kind, cchar *fmt, va_list args)
{
EspReq *req;
cchar *prior, *msg;
req = conn->data;
msg = sfmtv(fmt, args);
if (req->flash == 0) {
req->flash = mprCreateHash(0, MPR_HASH_STABLE);
}
if ((prior = mprLookupKey(req->flash, kind)) != 0) {
mprAddKey(req->flash, kind, sjoin(prior, "\n", msg, NULL));
} else {
mprAddKey(req->flash, kind, sclone(msg));
}
/*
Create a session as early as possible so a Set-Cookie header can be omitted.
*/
httpGetSession(conn, 1);
}
void espSetFlashv(HttpConn *conn, cchar *kind, cchar *fmt, va_list args)
{
EspReq *req;
MprKey *kp;
cchar *prior, *msg;
req = conn->data;
msg = sfmtv(fmt, args);
if (req->flash == 0) {
req->flash = mprCreateHash(0, 0);
httpGetSession(conn, 1);
}
if ((prior = mprLookupKey(req->flash, kind)) != 0) {
kp = mprAddKey(req->flash, kind, sjoin(prior, "\n", msg, NULL));
} else {
kp = mprAddKey(req->flash, kind, sclone(msg));
}
if (kp) {
kp->type = MPR_JSON_STRING;
}
}
/*
Compute a set of abilities for a role. Role strings can be either roles or abilities.
The abilities hash is updated.
*/
PUBLIC void httpComputeRoleAbilities(HttpAuth *auth, MprHash *abilities, cchar *role)
{
MprKey *ap;
HttpRole *rp;
if ((rp = mprLookupKey(auth->roles, role)) != 0) {
/* Interpret as a role */
for (ITERATE_KEYS(rp->abilities, ap)) {
if (!mprLookupKey(abilities, ap->key)) {
mprAddKey(abilities, ap->key, MPR->oneString);
}
}
} else {
/*
Can also achieve this via abilities
*/
PUBLIC void httpSetAuthPermittedUsers(HttpAuth *auth, cchar *users)
{
char *user, *tok;
GRADUATE_HASH(auth, permittedUsers);
for (user = stok(sclone(users), " \t,", &tok); users; users = stok(NULL, " \t,", &tok)) {
if (smatch(user, "*")) {
auth->permittedUsers = 0;
break;
} else {
mprAddKey(auth->permittedUsers, user, user);
}
}
}
PUBLIC HttpAuthStore *httpCreateAuthStore(cchar *name, HttpVerifyUser verifyUser)
{
HttpAuthStore *store;
if ((store = mprAllocObj(HttpAuthStore, manageAuthStore)) == 0) {
return 0;
}
store->name = sclone(name);
store->verifyUser = verifyUser;
if (mprAddKey(HTTP->authStores, name, store) == 0) {
return 0;
}
return store;
}
PUBLIC void httpSetTraceFormatterName(HttpTrace *trace, cchar *name)
{
HttpTraceFormatter formatter;
if (name && smatch(name, "common")) {
if ((trace->events = mprCreateHash(0, MPR_HASH_STATIC_VALUES)) == 0) {
return;
}
mprAddKey(trace->events, "complete", ITOP(0));
formatter = httpCommonTraceFormatter;
} else {
formatter = httpDetailTraceFormatter;
}
httpSetTraceFormatter(trace, formatter);
}
PUBLIC void espDefineAction(HttpRoute *route, cchar *target, void *action)
{
EspRoute *eroute;
Esp *esp;
assert(route);
assert(target && *target);
assert(action);
esp = MPR->espService;
if (target) {
eroute = route->eroute;
mprAddKey(esp->actions, mprJoinPath(eroute->controllersDir, target), action);
}
}
/*
Path should be an app-relative path to the view file (relative-path.esp)
*/
PUBLIC void espDefineView(HttpRoute *route, cchar *path, void *view)
{
Esp *esp;
assert(path && *path);
assert(view);
if (!route) {
mprError("Route not defined for view %s", path);
return;
}
esp = MPR->espService;
path = mprGetPortablePath(mprJoinPath(route->documents, path));
mprAddKey(esp->views, path, view);
}
/*
Path should be a relative path from route->documents to the view file (relative-path.esp)
*/
PUBLIC void espDefineView(HttpRoute *route, cchar *path, void *view)
{
EspRoute *eroute;
assert(path && *path);
assert(view);
eroute = ((EspRoute*) route->eroute)->top;
if (route) {
path = mprGetPortablePath(path);
}
if (!eroute->views) {
eroute->views = mprCreateHash(-1, MPR_HASH_STATIC_VALUES);
}
mprAddKey(eroute->views, path, view);
}
PUBLIC void ecInitLexer(EcCompiler *cp)
{
ReservedWord *rp;
int size;
size = sizeof(keywords) / sizeof(ReservedWord);
if ((cp->keywords = mprCreateHash(size, MPR_HASH_UNICODE | MPR_HASH_STATIC_KEYS | MPR_HASH_STATIC_VALUES)) == 0) {
return;
}
for (rp = keywords; rp->name; rp++) {
#if BIT_CHAR_LEN > 1
rp->name = amtow(cp->keywords, rp->name, NULL);
#endif
mprAddKey(cp->keywords, rp->name, rp);
}
}
static void testIterateHash(MprTestGroup *gp)
{
MprHash *table;
MprKey *sp;
char name[80], address[80];
cchar *where;
int count, i, check[HASH_COUNT];
table = mprCreateHash(HASH_COUNT, 0);
memset(check, 0, sizeof(check));
/*
Fill the table
*/
for (i = 0; i < HASH_COUNT; i++) {
mprSprintf(name, sizeof(name), "Bit longer name.%d", i);
mprSprintf(address, sizeof(address), "%d Park Ave", i);
sp = mprAddKey(table, name, sclone(address));
assert(sp != 0);
}
assert(mprGetHashLength(table) == HASH_COUNT);
/*
Check data entered into the table
*/
sp = mprGetFirstKey(table);
count = 0;
while (sp) {
assert(sp != 0);
where = sp->data;
assert(isdigit((int) where[0]) != 0);
i = atoi(where);
check[i] = 1;
sp = mprGetNextKey(table, sp);
count++;
}
assert(count == HASH_COUNT);
count = 0;
for (i = 0; i < HASH_COUNT; i++) {
if (check[i]) {
count++;
}
}
assert(count == HASH_COUNT);
}
PUBLIC int httpCreateAuthType(cchar *name, HttpAskLogin askLogin, HttpParseAuth parseAuth, HttpSetAuth setAuth)
{
HttpAuthType *type;
if ((type = mprAllocObj(HttpAuthType, manageAuthType)) == 0) {
return MPR_ERR_CANT_CREATE;
}
type->name = sclone(name);
type->askLogin = askLogin;
type->parseAuth = parseAuth;
type->setAuth = setAuth;
if (mprAddKey(HTTP->authTypes, name, type) == 0) {
return MPR_ERR_CANT_CREATE;
}
return 0;
}
PUBLIC void espSetFlashv(HttpConn *conn, cchar *kind, cchar *fmt, va_list args)
{
EspReq *req;
cchar *msg;
req = conn->reqData;
msg = sfmtv(fmt, args);
if (req->flash == 0) {
req->flash = mprCreateHash(0, MPR_HASH_STABLE);
}
mprAddKey(req->flash, kind, sclone(msg));
/*
Create a session as early as possible so a Set-Cookie header can be omitted.
*/
httpGetSession(conn, 1);
}
void espDefineAction(HttpRoute *route, cchar *target, void *actionProc)
{
EspAction *action;
EspRoute *eroute;
Esp *esp;
mprAssert(route);
mprAssert(target && *target);
mprAssert(actionProc);
esp = MPR->espService;
if ((action = mprAllocObj(EspAction, espManageAction)) == 0) {
return;
}
action->actionProc = actionProc;
if (target) {
eroute = route->eroute;
mprAddKey(esp->actions, mprJoinPath(eroute->controllersDir, target), action);
}
}
static void testInsertAndRemoveHash(MprTestGroup *gp)
{
MprHash *table;
MprKey *sp;
cchar *str;
int rc;
table = mprCreateHash(0, MPR_HASH_STATIC_KEYS | MPR_HASH_STATIC_VALUES);
assert(table != 0);
/*
Single insert
*/
sp = mprAddKey(table, "Peter", "123 Madison Ave");
assert(sp != 0);
sp = mprGetFirstKey(table);
assert(sp != 0);
assert(sp->key != 0);
assert(strcmp(sp->key, "Peter") == 0);
assert(sp->data != 0);
assert(strcmp(sp->data, "123 Madison Ave") == 0);
/*
Lookup
*/
str = mprLookupKey(table, "Peter");
assert(str != 0);
assert(strcmp(str, "123 Madison Ave") == 0);
rc = mprRemoveKey(table, "Peter");
assert(rc == 0);
assert(mprGetHashLength(table) == 0);
sp = mprGetFirstKey(table);
assert(sp == 0);
str = mprLookupKey(table, "Peter");
assert(str == 0);
}
