/**
* 为当前访问者启用 session
*
* @param const char* datadir 用于保存 session 数据文件的目录
*
* @return int 成功返回0，失败返回非0值
*/
int session_start(const char* datadir) {
char cookie_session_id[34];
int result;
if (g_session_data != NULL) {
fprintf(cgiOut, "Warning: session_start() calls again.<br />\n");
return -1;
}
// 初始化 session_data
sess_init(datadir);
// 根据 cookie 状态确定是创建新 session 还是载入现有的 session
result = cgiCookieString("CWEB_SESSION_ID", cookie_session_id, 33);
#ifdef DEBUG
fprintf(cgiOut, "cgiCookieString() result: %u\n", result);
fprintf(cgiOut, "cookie_session_id: %s\n", cookie_session_id);
#endif
if (result != cgiFormSuccess) {
// 没有找到有效的 cookie session_id，创建一个新 session
result = sess_create();
} else {
result = sess_load(cookie_session_id, datadir);
}
sess_gc(); //处理过期session
return result;
}
/**
* 载入现有的 session
*
* @param const char* session_id 要读取的 session_id
* @param const char* datadir
*
* @return int 成功返回0，失败返回非0值
*/
int sess_load(const char* session_id, const char* datadir) {
FILE* fp = NULL;
char* buffer = NULL;
char* tmp = NULL;
SESSION_ITEM_LIST tmp_list =
NULL;
size_t buffer_length = 2048;
int index = 0;
if (g_session_data == NULL) {
return -1;
}
#ifdef DEBUG
fprintf(cgiOut, "sess_load() BEGIN -->\n");
#endif
// 构造 session_data
g_session_data->session_id = (char*) malloc(
(strlen(session_id) + 1) * sizeof(char));
strcpy(g_session_data->session_id, session_id);
g_session_data->session_filename = sess_get_filename(
g_session_data->session_datadir, g_session_data->session_id);
#ifdef DEBUG
fprintf(cgiOut, "sess_load(), session file:%s\n", g_session_data->session_filename);
#endif
fp = fopen(g_session_data->session_filename, "r");
if (fp == NULL) {
// 无效的 session_filename
sess_free_resource();
sess_init(datadir);
return sess_create();
}
buffer = (char*) malloc(buffer_length * sizeof(char));
tmp = buffer;
while (!feof(fp)) {
if (fgets(tmp, buffer_length, fp) == NULL) {
break;
}
/*
if (buffer[strlen(buffer) + 1] != '\n' && !feof(fp)) {
// 缓冲区太小，无法容纳该行字符串
buffer_length += buffer_length;
tmp = (char*)malloc(buffer_length * sizeof(char));
strcpy(tmp, buffer);
free(buffer);
buffer = tmp;
tmp = buffer += strlen(buffer);
continue;
}
*/
// 如果 count >= max_index，则需要增加列表容量
if (g_session_data->count >= g_session_data->max_index) {
g_session_data->max_index += 10;
#ifdef DEBUG
fprintf(cgiOut, "* items count: %ld, max_index grow up to: %ld\n",
g_session_data->count,
g_session_data->max_index);
#endif
tmp_list = (SESSION_ITEM_LIST) malloc(
g_session_data->max_index * sizeof(SESSION_ITEM));
memset(tmp_list, 0,
g_session_data->max_index * sizeof(SESSION_ITEM));
if (g_session_data->items != NULL) {
memcpy(tmp_list, g_session_data->items,
g_session_data->count * sizeof(SESSION_ITEM));
free(g_session_data->items);
}
g_session_data->items = tmp_list;
tmp_list = NULL;
}
// 添加一个新项目
if ((index % 2) == 0) {
tmp = g_session_data->items[g_session_data->count].name;
#ifdef DEBUG
fprintf(cgiOut, "read name:");
#endif
} else {
tmp = g_session_data->items[g_session_data->count].string;
#ifdef DEBUG
fprintf(cgiOut, "read string:");
#endif
}
if (buffer[strlen(buffer) - 1] == '\n') {
buffer[strlen(buffer) - 1] = '\0';
}
tmp = sess_unserialize(buffer);
#ifdef DEBUG
fprintf(cgiOut, "%s\n", tmp);
#endif
if ((index % 2) == 0) {
g_session_data->items[g_session_data->count].name = tmp;
} else {
g_session_data->items[g_session_data->count].string = tmp;
g_session_data->count++;
}
// 增加索引，准备读取下一行
tmp = buffer;
index++;
}
free(buffer);
fclose(fp);
if ((index % 2) != 0) {
free(g_session_data->items[g_session_data->count - 1].name);
g_session_data->items[g_session_data->count - 1].name =
NULL;
}
#ifdef DEBUG
session_dump(cgiOut);
#endif
#ifdef DEBUG
fprintf(cgiOut, "sess_load() END -->\n");
#endif
return 0;
}
/* ARGSUSED */
int
setpgrp(int flag, int pid, int pgid)
{
register proc_t *p = ttoproc(curthread);
register int retval = 0;
switch (flag) {
case 1: /* setpgrp() */
mutex_enter(&pidlock);
if (p->p_sessp->s_sidp != p->p_pidp && !pgmembers(p->p_pid)) {
mutex_exit(&pidlock);
sess_create();
} else
mutex_exit(&pidlock);
return (p->p_sessp->s_sid);
case 3: /* setsid() */
mutex_enter(&pidlock);
if (p->p_pgidp == p->p_pidp || pgmembers(p->p_pid)) {
mutex_exit(&pidlock);
return (set_errno(EPERM));
}
mutex_exit(&pidlock);
sess_create();
return (p->p_sessp->s_sid);
case 5: /* setpgid() */
{
mutex_enter(&pidlock);
if (pid == 0)
pid = p->p_pid;
else if (pid < 0 || pid >= maxpid) {
mutex_exit(&pidlock);
return (set_errno(EINVAL));
} else if (pid != p->p_pid) {
for (p = p->p_child; /* empty */; p = p->p_sibling) {
if (p == NULL) {
mutex_exit(&pidlock);
return (set_errno(ESRCH));
}
if (p->p_pid == pid)
break;
}
if (p->p_flag & SEXECED) {
mutex_exit(&pidlock);
return (set_errno(EACCES));
}
if (p->p_sessp != ttoproc(curthread)->p_sessp) {
mutex_exit(&pidlock);
return (set_errno(EPERM));
}
}
if (p->p_sessp->s_sid == pid) {
mutex_exit(&pidlock);
return (set_errno(EPERM));
}
if (pgid == 0)
pgid = p->p_pid;
else if (pgid < 0 || pgid >= maxpid) {
mutex_exit(&pidlock);
return (set_errno(EINVAL));
}
if (p->p_pgrp == pgid) {
mutex_exit(&pidlock);
break;
} else if (p->p_pid == pgid) {
/*
* We need to protect p_pgidp with p_lock because
* /proc looks at it while holding only p_lock.
*/
mutex_enter(&p->p_lock);
pgexit(p);
pgjoin(p, p->p_pidp);
mutex_exit(&p->p_lock);
} else {
register proc_t *q;
if ((q = pgfind(pgid)) == NULL ||
q->p_sessp != p->p_sessp) {
mutex_exit(&pidlock);
return (set_errno(EPERM));
}
/*
* See comment above about p_lock and /proc
*/
mutex_enter(&p->p_lock);
pgexit(p);
pgjoin(p, q->p_pgidp);
mutex_exit(&p->p_lock);
}
mutex_exit(&pidlock);
break;
}
case 0: /* getpgrp() */
mutex_enter(&pidlock);
retval = p->p_pgrp;
mutex_exit(&pidlock);
break;
case 2: /* getsid() */
case 4: /* getpgid() */
if (pid < 0 || pid >= maxpid) {
return (set_errno(EINVAL));
}
mutex_enter(&pidlock);
if (pid != 0 && p->p_pid != pid &&
((p = prfind(pid)) == NULL || p->p_stat == SIDL)) {
mutex_exit(&pidlock);
return (set_errno(ESRCH));
}
if (flag == 2)
retval = p->p_sessp->s_sid;
else
retval = p->p_pgrp;
mutex_exit(&pidlock);
break;
}
return (retval);
}
