cmhi
/
secgateway
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Mod aaa-12 修改用户认证配置管理-数据存在内存中，点击保存才存入数据库内 

RCA：
SOL：
修改人：chenling
检视人：
This commit is contained in:
ChenLing 2019-09-02 11:24:08 +08:00
parent da7fe8c673
commit aff9a79031
6 changed files with 709 additions and 424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

528
Platform/user/configm/config-server/web_config/authfree.c
View File

@ -16,6 +16,9 @@
/*定义结构体数组 存在免认证规则 */
freeauth_configure_t freeauth_array[RULE_MAX_NUM] = {0};
/*存储序列号的数组*/
int rule_order[RULE_MAX_NUM] = {0};
#define UNAMESIZE (60 + 1)
#define SPECHAR(element) (strpbrk((element), "~!@#$%^&*()_+{}|:\"<>?\\,./;\'[]-=`")) //校验特殊字符
@ -23,6 +26,7 @@ freeauth_configure_t freeauth_array[RULE_MAX_NUM] = {0};
#define CFG_FREEAUTH_ACK_COOKIES
#endif
/* 判断IPv4格式是否正确*/
int isIpV4Addr(const char *ipAddr)
{
@ -159,6 +163,57 @@ ret_code freeauth_config_json_type(pointer input, uint *conf_type)
}
/*修改json字符串转为结构体 把未认证权限名称为name的序号移动到序号3前面*/
/*iuput格式：{"type": 1, "data": {"name": "armink", "after": 3}}*/
ret_code freeauth_mov_json_parse(pointer input, uint *conf_type, rule_mod_t *rule_mod)
{
const char *pString = (char *)input;
cJSON *cjson, *type, *data;
if(!pString) {
return RET_INPUTERR;
}
printf("json:[%s]\n", pString);
/*JSON字符串到JSON格式 */
cjson = cJSON_Parse(pString);
if(!cjson) {
return RET_INPUTERR;
}
/*获取免认证规则的data部分 */
data = cJSON_GetObjectItem(cjson, "data");
if(!data) {
cJSON_Delete(cjson);
return RET_INPUTERR;
}
/*创建freeauth_configure_t结构体对象 */
s2j_create_struct_obj(struct_rulemod, rule_mod_t);
if(struct_rulemod == NULL) {
cJSON_Delete(cjson);
return RET_NOMEM;
}
/*反序列化数据到freeauth_configure_t结构体对象 */
s2j_struct_get_basic_element(struct_rulemod, data, int, after);
s2j_struct_get_basic_element(struct_rulemod, data, string, name);
if(rule_mod) {
memset(rule_mod, 0, sizeof(rule_mod_t));
rule_mod->after = struct_rulemod->after;
strncpy(rule_mod->name, struct_rulemod->name, 31);
}
printf("移动数据解析完成\n");
cJSON_Delete(cjson);
return RET_OK;
}
/*json字符串转为结构体*/
/*iuput格式：{"type": 0, "data": {"rule_priority": 1, "name": "armink","sip": 1027824,"dip": 103427824,"dport": 24, "flag":0}}*/
ret_code freeauth_config_json_parse(pointer input, uint *conf_type, freeauth_configure_t *freeauth_buff)
@ -224,6 +279,7 @@ ret_code freeauth_config_json_parse(pointer input, uint *conf_type, freeauth_con
freeauth_buff->flag = struct_freeauth->flag;
}
printf("添加数据解析完成\n");
cJSON_Delete(cjson);
s2j_delete_struct_obj(struct_freeauth);
@ -241,7 +297,7 @@ ret_code freeauth_config_json_parse(pointer input, uint *conf_type, freeauth_con
]
}
*/
ret_code authpara_config_json_parse_array(pointer input, uint *conf_type, freeauth_configure_t **fb, int *cnt)
ret_code authfree_config_json_parse_array(pointer input, uint *conf_type, freeauth_configure_t **fb, int *cnt)
{
cJSON *cjson, *data, *rule_priority, *name, *sip, *dip, *dport, *flag;
freeauth_configure_t *freeauth_buff = *fb;
@ -297,6 +353,8 @@ ret_code authpara_config_json_parse_array(pointer input, uint *conf_type, freeau
if(name) {
strncpy(freeauth_buff->name, name->valuestring, 31);
printf("freeauth_buff->name = %s\n", freeauth_buff->name);
}
/*源IP地址*/
@ -349,15 +407,10 @@ ret_code authpara_config_json_parse_array(pointer input, uint *conf_type, freeau
}
cJSON_Delete(cjson);
printf("删除数据解析完成\n");
return RET_OK;
}
ret_code authpara_config_json_parse_del_array(pointer input, uint *conf_type, freeauth_configure_t **fb, int *cnt)
{
return authpara_config_json_parse_array(input, conf_type, fb, cnt);
}
/*chk data格式 */
ret_code freeauth_config_chk(uint source, uint *config_type,
@ -404,17 +457,7 @@ ret_code freeauth_config_add_proc(uint source, uint config_type,
printf("username 含有特殊字符\n");
return RET_INPUTERR;
}
#if 0
/*校验优先级是否重名,如果优先级已经存在 则退出程序*/
for(i = 0; i < RULE_MAX_NUM; i++){
if(freeauth_array[i].rule_priority == freeauth_configure->rule_priority) {
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &freeauth_array[i]);
free(freeauth_configure);
return RET_EXIST;
}
}
#endif
/*校验端口号*/
if((freeauth_configure->dport < DPORT_MIN_NUM) || (freeauth_configure->dport > DPORT_MAX_NUM)) {
@ -445,7 +488,7 @@ ret_code freeauth_config_add_proc(uint source, uint config_type,
ret_int = strlen(ret_char);
if(output_len) {
*output_len = ret_int;
*output_len = ret_int + 1;
}
/*超出2k的内存，报错 */
@ -455,7 +498,7 @@ ret_code freeauth_config_add_proc(uint source, uint config_type,
return RET_NOMEM;
}
memcpy(output, ret_char, ret_int + 1);
memcpy(output, ret_char, ret_int);
free(ret_char);
cJSON_Delete(res);
@ -509,7 +552,7 @@ ret_code freeauth_config_add_proc(uint source, uint config_type,
ret_int = strlen(ret_char);
if(output_len) {
*output_len = ret_int;
*output_len = ret_int + 1;
}
/*超出2k的内存，报错 */
@ -520,7 +563,7 @@ ret_code freeauth_config_add_proc(uint source, uint config_type,
return RET_NOMEM;
}
memcpy(output, ret_char, ret_int + 1);
memcpy(output, ret_char, ret_int);
free(ret_char);
cJSON_Delete(res);
@ -529,28 +572,28 @@ ret_code freeauth_config_add_proc(uint source, uint config_type,
return RET_OK;
}
ret_code freeauth_config_mod_proc(uint source, uint config_type,
ret_code freeauth_config_mov_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len)
{
int i;
int cnt;
cJSON *res;
cJSON *pJsonArry;
cJSON *pJsonsub;
authfree_result_t authfree_result;
freeauth_configure_t *freeauth_configure = NULL;
rule_mod_t *rule_mod;
uint conf_type = FREEAUTH_CONFIG_GET;
char *ret_char = NULL;
unsigned int ret_int = 0;
cJSON *pJsonArry, *pJsonsub;
authpara_config_json_parse_array(input, &conf_type, &freeauth_configure, &cnt);
freeauth_mov_json_parse(input, &conf_type, rule_mod);
printf("%s %d\n", rule_mod->name, rule_mod->after);
if(input_len < sizeof(freeauth_configure_t)) {
if(input_len < sizeof(rule_mod_t)) {
return RET_INPUTERR;
}
printf("打印全局数组内全部元素\n");
/*打印数组内全部元素*/
for(i = 0; i < RULE_MAX_NUM; i++)
@ -559,104 +602,49 @@ ret_code freeauth_config_mod_proc(uint source, uint config_type,
freeauth_array[i].dip, freeauth_array[i].dport, freeauth_array[i].dport, i);
}
printf("打印传过来的json串\n");
for(int j = 0; j < cnt; j++)
{
printf("[%d %s %d %d %d %d %d]\n", freeauth_configure[j].rule_priority, freeauth_configure[j].name, freeauth_configure[j].sip,
freeauth_configure[j].dip, freeauth_configure[j].dport, freeauth_configure[j].dport, j);
}
pJsonArry= cJSON_CreateArray(); /*创建数组*/
/*查找要修改的免认证规则名字，不存在则退出程序 */
/*查找要移动的未认证权限是否存在 不存在 则退出程序 */
for(i = 0; i < RULE_MAX_NUM; i++) {
/*两个字符串相等 strcmp值为0*/
for(int j = 0; j < cnt; j++) {
if(0 == strcmp(freeauth_array[i].name, rule_mod->name)) {
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &freeauth_array[i]);
if(0 == strcmp(freeauth_array[i].name, freeauth_configure[j].name)) {
printf("%s %d\n", freeauth_array[i].name, i);
printf("%s %d\n", freeauth_configure[j].name, j);
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &freeauth_array[j]);
/*数据库修改 存入全局变量*/
mod_authfree(freeauth_configure[j].rule_priority, freeauth_configure[j].name, freeauth_configure[j].sip, freeauth_configure[j].dip,
freeauth_configure[j].dport, freeauth_configure[j].flag, &authfree_result);
mov_authfree(rule_mod->name, rule_mod->after, &authfree_result);
#if 0
/*用户态下发到内核态auth_hook */
int r = -1;
printf("cfgchannel main begin:\r\n");
/*创建json对象 */
res = cJSON_CreateObject();
/*创建通道 */
r = commcfgnl_open();
if(r < 0) {
printf(" pdlivnl_open fail, exit.\r\n");
return RET_ERR;
}
/*下发配置到内核态 */
r = set_freeauthcfg_waitack(freeauth_configure);
if(r < 0) {
printf("set_cfg_debug_waitack failed.\r\n");
return RET_ERR;
}
/*关闭netlink通道 */
commcfgnl_close();
printf("cfgchannel main exit!\r\n");
#endif
cJSON_AddItemToArray(pJsonArry, pJsonsub=cJSON_CreateObject()); /* 给创建的数组增加对象*/
/*在json对象上添加键值对*/
char *result_message = malloc(strlen(freeauth_configure[j].name)+strlen(authfree_result.message)+1);//+1 for the zero-terminator
//in real code you would check for errors in malloc here
if (result_message == NULL)
{
return RET_NOMEM;
}
strcpy(result_message, freeauth_configure[j].name);
strcat(result_message, authfree_result.message);
printf("%s\n", result_message);
cJSON_AddNumberToObject(pJsonsub, "resultcode", authfree_result.resultcode);
cJSON_AddStringToObject(pJsonsub, "message", result_message);
ret_char = cJSON_Print(pJsonArry);
ret_int = strlen(ret_char);
if(output_len)
{
*output_len = ret_int;
}
/*超出2k的内存，报错 */
if(ret_int >= 1024 * 2)
{
free(ret_char);
cJSON_Delete(pJsonArry);
return RET_NOMEM;
}
memcpy(output, ret_char, ret_int + 1);
free(ret_char);
if(!res) {
return RET_ERR;
}
/*将json对象转换成json字符串 返回处理结果*/
cJSON_AddNumberToObject(res, "resultcode", authfree_result.resultcode);
cJSON_AddStringToObject(res, "message", authfree_result.message);
ret_char = cJSON_PrintUnformatted(res);
ret_int = strlen(ret_char);
if(output_len) {
*output_len = ret_int + 1;
}
/*超出2k的内存，报错 */
if(ret_int >= 1024 * 2) {
free(ret_char);
cJSON_Delete(res);
return RET_NOMEM;
}
memcpy(output, ret_char, ret_int);
free(ret_char);
cJSON_Delete(res);
return RET_OK;
}
}
if(freeauth_configure) {
free(freeauth_configure);
}
return RET_OK;
}
ret_code freeauth_config_del_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len)
@ -664,22 +652,19 @@ ret_code freeauth_config_del_proc(uint source, uint config_type,
int i;
int cnt;
cJSON *res;
cJSON *pJsonArry;
cJSON *pJsonsub;
authfree_result_t authfree_result;
freeauth_configure_t *freeauth_configure = NULL;
uint conf_type = FREEAUTH_CONFIG_GET;
char *ret_char = NULL;
unsigned int ret_int = 0;
cJSON *pJsonArry, *pJsonsub;
authpara_config_json_parse_del_array(input, &conf_type, &freeauth_configure, &cnt);
authfree_config_json_parse_array(input, &conf_type, &freeauth_configure, &cnt);
if(input_len < sizeof(freeauth_configure_t)) {
return RET_INPUTERR;
}
printf("打印全局数组内全部元素\n");
/*打印数组内全部元素*/
for(i = 0; i < RULE_MAX_NUM; i++)
@ -693,89 +678,159 @@ ret_code freeauth_config_del_proc(uint source, uint config_type,
{
printf("[%s %d]\n", freeauth_configure[j].name, j);
}
pJsonArry= cJSON_CreateArray(); /*创建数组*/
/*查找要修改的免认证规则名字，不存在则退出程序 */
pJsonArry= cJSON_CreateArray(); /*创建数组*/
/*数据库删除 存入全局变量*/
for(int j = 0; j < cnt; j++) {
del_authfree(freeauth_configure[j].name, &authfree_result);
cJSON_AddItemToArray(pJsonArry, pJsonsub=cJSON_CreateObject()); /* 给创建的数组增加对象*/
/*在json对象上添加键值对*/
char *result_message = malloc(strlen(freeauth_configure[j].name)+strlen(authfree_result.message)+1);//+1 for the zero-terminator
//in real code you would check for errors in malloc here
if (result_message == NULL)
{
return RET_NOMEM;
}
strcpy(result_message, freeauth_configure[j].name);
strcat(result_message, authfree_result.message);
printf("%s\n", result_message);
cJSON_AddNumberToObject(pJsonsub, "resultcode", authfree_result.resultcode);
cJSON_AddStringToObject(pJsonsub, "message", result_message);
ret_char = cJSON_Print(pJsonArry);
ret_int = strlen(ret_char);
if(output_len)
{
*output_len = ret_int + 1;
}
/*超出2k的内存，报错 */
if(ret_int >= 1024 * 2)
{
free(ret_char);
cJSON_Delete(pJsonArry);
return RET_NOMEM;
}
memcpy(output, ret_char, ret_int);
}
free(ret_char);
return RET_OK;
}
/*修改未认证权限规则*/
ret_code freeauth_config_mod_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len)
{
int i;
cJSON *res;
freeauth_configure_t *freeauth_configure;
uint conf_type = FREEAUTH_CONFIG_GET;
char *ret_char = NULL;
unsigned int ret_int = 0;
authfree_result_t authfree_result;
freeauth_configure = (freeauth_configure_t *)malloc(sizeof(freeauth_configure_t));
if(freeauth_configure == NULL) {
return RET_NOMEM;
}
freeauth_config_json_parse(input, &conf_type, freeauth_configure);
/*校验用户名长度*/
if(input_len < sizeof(freeauth_configure_t) || NULL == freeauth_configure->name ||
(UNAMESIZE) < strlen(freeauth_configure->name) || 0 == strlen(freeauth_configure->name)) {
free(freeauth_configure);
printf("the lenth is error\n");
return RET_INPUTERR;
}
/*查找要增加的未认证权限是否重名 该名字不存在 则退出程序 */
for(i = 0; i < RULE_MAX_NUM; i++) {
/*两个字符串相等 strcmp值为0*/
for(int j = 0; j < cnt; j++) {
if(0 == strcmp(freeauth_array[i].name, freeauth_configure[j].name))
{
printf("hello\n");
if(0 == strcmp(freeauth_array[i].name, freeauth_configure->name)) {
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &freeauth_array[i]);
printf("%s %d\n",freeauth_array[i].name, i);
printf("%s %d\n",freeauth_configure[j].name, j);
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &freeauth_array[j]);
/*数据库删除 存入全局变量*/
del_authfree(freeauth_configure[j].name, &authfree_result);
#if 0
/*用户态下发到内核态auth_hook */
int r = -1;
printf("cfgchannel main begin:\r\n");
/*数据库修改 存入全局变量*/
mod_authfree(freeauth_configure->rule_priority, freeauth_configure->name, freeauth_configure->sip, freeauth_configure->dip,
freeauth_configure->dport, freeauth_configure->flag, &authfree_result);
/*创建通道 */
r = commcfgnl_open();
#if 0
/*用户态下发到内核态auth_hook */
int r = -1;
printf("cfgchannel main begin:\r\n");
if(r < 0) {
printf(" pdlivnl_open fail, exit.\r\n");
return RET_ERR;
}
/*创建通道 */
r = commcfgnl_open();
/*下发配置到内核态 */
r = set_freeauthcfg_waitack(freeauth_configure);
if(r < 0) {
printf(" pdlivnl_open fail, exit.\r\n");
return RET_ERR;
}
if(r < 0) {
printf("set_cfg_debug_waitack failed.\r\n");
return RET_ERR;
}
/*下发配置到内核态 */
r = set_freeauthcfg_waitack(freeauth_configure);
/*关闭netlink通道 */
commcfgnl_close();
printf("cfgchannel main exit!\r\n");
#endif
if(r < 0) {
printf("set_cfg_debug_waitack failed.\r\n");
return RET_ERR;
}
cJSON_AddItemToArray(pJsonArry, pJsonsub=cJSON_CreateObject());
/*在json对象上添加键值对*/
char *result_message = malloc(strlen(freeauth_configure[j].name)+strlen(authfree_result.message)+1);//+1 for the zero-terminator
//in real code you would check for errors in malloc here
if (result_message == NULL)
{
return RET_NOMEM;
}
/*关闭netlink通道 */
commcfgnl_close();
printf("cfgchannel main exit!\r\n");
#endif
strcpy(result_message, freeauth_configure[j].name);
strcat(result_message, authfree_result.message);
printf("%s\n", result_message);
cJSON_AddNumberToObject(pJsonsub, "resultcode", authfree_result.resultcode);
cJSON_AddStringToObject(pJsonsub, "message", result_message);
/*创建json对象 */
res = cJSON_CreateObject();
ret_char = cJSON_Print(pJsonArry);
ret_int = strlen(ret_char);
if(!res) {
free(freeauth_configure);
return RET_ERR;
}
if(output_len)
{
*output_len = ret_int;
}
/*将json对象转换成json字符串 返回处理结果*/
cJSON_AddNumberToObject(res, "resultcode", authfree_result.resultcode);
cJSON_AddStringToObject(res, "message", authfree_result.message);
ret_char = cJSON_PrintUnformatted(res);
ret_int = strlen(ret_char);
/*超出2k的内存，报错 */
if(ret_int >= 1024 * 2)
{
free(ret_char);
cJSON_Delete(res);
return RET_NOMEM;
}
if(output_len) {
*output_len = ret_int + 1;
}
memcpy(output, ret_char, ret_int + 1);
/*超出2k的内存，报错 */
if(ret_int >= 1024 * 2) {
free(ret_char);
free(freeauth_configure);
cJSON_Delete(res);
return RET_NOMEM;
}
free(ret_char);
}
}
memcpy(output, ret_char, ret_int);
free(ret_char);
cJSON_Delete(res);
free(freeauth_configure);
return RET_OK;
}
}
if(freeauth_configure) {
if(freeauth_configure) {
free(freeauth_configure);
}
@ -783,6 +838,86 @@ ret_code freeauth_config_del_proc(uint source, uint config_type,
}
/*查询未认证权限*/
ret_code freeauth_config_get_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len)
{
int i;
int cnt;
cJSON *res;
char *ret_char = NULL;
unsigned int ret_int = 0;
uint conf_type = FREEAUTH_CONFIG_GET;
cJSON *pJsonArry, *pJsonsub;
char *name;
printf("打印全局数组内全部元素\n");
/*打印数组内全部元素*/
for(i = 0; i < RULE_MAX_NUM; i++)
{
printf("[%d %s %d %d %d %d %d]\n", freeauth_array[i].rule_priority, freeauth_array[i].name, freeauth_array[i].sip,
freeauth_array[i].dip, freeauth_array[i].dport, freeauth_array[i].dport, i);
}
pJsonArry= cJSON_CreateArray(); /*创建数组*/
/*打印数组内全部元素*/
/*查找免认证规则名字，不存在则退出程序 */
for(i = 0; i < RULE_MAX_NUM; i++) {
if (0 != strlen(freeauth_array[i].name))
{
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &freeauth_array[i]);
cJSON_AddItemToArray(pJsonArry, pJsonsub=cJSON_CreateObject()); /* 给创建的数组增加对象*/
cJSON_AddNumberToObject(pJsonsub, "rule_priority", (i + 1));
cJSON_AddStringToObject(pJsonsub, "name", freeauth_array[i].name);
cJSON_AddNumberToObject(pJsonsub, "sip", freeauth_array[i].sip);
cJSON_AddNumberToObject(pJsonsub, "dip", freeauth_array[i].dip);
cJSON_AddNumberToObject(pJsonsub, "dport", freeauth_array[i].dport);
cJSON_AddNumberToObject(pJsonsub, "flag", freeauth_array[i].flag);
}
}
char *ret_arry = cJSON_PrintUnformatted(pJsonArry);
printf("%s\n", ret_arry);
/*创建json对象 */
res = cJSON_CreateObject();
if(!res) {
return RET_ERR;
}
/*将json对象转换成json字符串 返回处理结果*/
cJSON_AddNumberToObject(res, "resultcode", 11);
cJSON_AddStringToObject(res, "message", "get success");
cJSON_AddStringToObject(res, "data", ret_arry);
ret_char = cJSON_PrintUnformatted(res);
ret_int = strlen(ret_char);
if(output_len) {
*output_len = ret_int + 1;
}
/*超出2k的内存，报错 */
if(ret_int >= 1024 * 2) {
free(ret_char);
cJSON_Delete(res);
return RET_NOMEM;
}
memcpy(output, ret_char, ret_int);
free(ret_char);
cJSON_Delete(res);
return RET_OK;
}
ret_code freeauth_config_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len)
@ -807,8 +942,8 @@ ret_code freeauth_config_proc(uint source, uint config_type,
output, output_len);
break;
case FREEAUTH_CONFIG_MOD:
ret = freeauth_config_mod_proc(source, conf_type,
case FREEAUTH_CONFIG_MOV:
ret = freeauth_config_mov_proc(source, conf_type,
input, input_len,
output, output_len);
break;
@ -819,6 +954,18 @@ ret_code freeauth_config_proc(uint source, uint config_type,
output, output_len);
break;
case FREEAUTH_CONFIG_MOD:
ret = freeauth_config_mod_proc(source, conf_type,
input, input_len,
output, output_len);
break;
case FREEAUTH_CONFIG_GET:
ret = freeauth_config_get_proc(source, conf_type,
input, input_len,
output, output_len);
break;
default:
ret = RET_NOTSUPPORT;
}
@ -829,4 +976,3 @@ ret_code freeauth_config_proc(uint source, uint config_type,

33
Platform/user/configm/config-server/web_config/authfree.h
View File

@ -18,9 +18,10 @@
#define RULE_MAX_NUM 10
#define FREEAUTH_CONFIG_ADD 0
#define FREEAUTH_CONFIG_MOD 1
#define FREEAUTH_CONFIG_MOV 1
#define FREEAUTH_CONFIG_DEL 2
#define FREEAUTH_CONFIG_GET 3
#define FREEAUTH_CONFIG_MOD 3
#define FREEAUTH_CONFIG_GET 4
/*配置消息 */
@ -34,6 +35,12 @@ typedef struct {
}freeauth_configure_t;
/*修改权限消息*/
typedef struct {
char name[32];
int after;
}rule_mod_t;
typedef struct {
int resultcode;
char *message;
@ -50,6 +57,11 @@ int set_freeauthcfg_waitack(freeauth_configure_t *struct_freeauth);
/*获取json串类型*/
ret_code freeauth_config_json_type(pointer input, uint *conf_type);
/*修改json字符串转为结构体 把未认证权限名称为name的序号移动到序号3前面*/
/*iuput格式：{"type": 1, "data": {"name": "armink", "after": 3}}*/
ret_code freeauth_mov_json_parse(pointer input, uint *conf_type, rule_mod_t *rule_mod);
/*json字符串转为结构体*/
/*iuput格式：{"type": 0, "data": {"rule_priority": 1, "name": "armink","sip": 1027824,"dip": 103427824,"dport": 24, "flag":0}}*/
ret_code freeauth_config_json_parse(pointer input, uint *conf_type, freeauth_configure_t *freeauth_buff);
@ -65,9 +77,8 @@ ret_code freeauth_config_json_parse(pointer input, uint *conf_type, freeauth_con
]
}
*/
ret_code authpara_config_json_parse_array(pointer input, uint *conf_type, freeauth_configure_t **fb, int *cnt);
ret_code authfree_config_json_parse_array(pointer input, uint *conf_type, freeauth_configure_t **fb, int *cnt);
ret_code authpara_config_json_parse_del_array(pointer input, uint *conf_type, freeauth_configure_t **fb, int *cnt);
/*chk data格式 */
ret_code freeauth_config_chk(uint source, uint *config_type,
@ -79,8 +90,8 @@ ret_code freeauth_config_add_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len);
/*修改未认证权限规则 */
ret_code freeauth_config_mod_proc(uint source, uint config_type,
/*移动未认证权限规则 */
ret_code freeauth_config_mov_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len);
@ -89,6 +100,16 @@ ret_code freeauth_config_del_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len);
/*修改未认证权限规则*/
ret_code freeauth_config_mod_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len);
/*查询未认证权限*/
ret_code freeauth_config_get_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len);
ret_code freeauth_config_proc(uint source, uint config_type,
pointer input, int input_len,
pointer output, int *output_len);

527
Platform/user/configm/config-server/web_config/config-adm/user_authfree.c
View File

@ -6,11 +6,13 @@
#include "../include/auth_common.h"
extern freeauth_configure_t freeauth_array[];
extern rule_order[];
extern void * auth_hdbc;
static char *authfreemes[] = {"addrule success", "addrule fail", "rule existed", "modrule success",
"modrule failure", "rule not found", "delrule success", "delrule fail", "rulenum exceed maxnum",
"rule full"
"rule full","mov success" , "get success",
};
static char *get_sql_ret_message(SQL_RET_CODE code)
@ -36,14 +38,7 @@ static int is_rule_full(void)
/*增加未认证权限规则*/
void add_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int dport, int flag, authfree_result_t *authfree_result)
{
//void *authfree_hdbc;
char *ret_sql = NULL;
int ret_add;
int ret;
int num;
int i;
int num_sql;
if(NULL == authfree_result) {
return;
}
@ -53,85 +48,11 @@ void add_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
return;
}
/* 连接数据库 */
#if 0
authfree_hdbc = connect_database(AUTHFREE_DATABASE_ID);
if(NULL == authfree_hdbc) {
printf("connetc failure\n");
return;
}
/*长整型bigint 浮点型double 字符串character(10)*/
printf("authfree_hdbc = %p\n", authfree_hdbc);
#endif
/*建表*/
ret = create_database_table(AUTHRECOVER_DATABASE_ID, auth_hdbc, "authfree", "create table authfree(rule_priority bigint, name character(32), sip bigint, dip bigint, dport bigint, flag bigint)");
printf("%d \n", ret);
#if 0
/*查询数据库是否存在该权限规则*/
char *select_sql = "SELECT rule_priority, name, sip, dip, dport, flag FROM `authfree` WHERE name = ?";
ret_sql = select_datebase_by_number(AUTHFREE_DATABASE_ID, authfree_hdbc, "authfree", select_sql, 1, 0, &num, 1,
DB_DATA_STRING_TYPE, strlen(name) + 1, name);
if(NULL != ret_sql) {
/*用户名已存在*/
printf("用户名已存在");
disconnect_database(AUTHFREE_DATABASE_ID, authfree_hdbc);
authfree_result->resultcode = RULE_EXISTED;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
return;
} else {
}
#endif
/* 根据指定信息查询数据库的获取的结果的条目数 条目数大于10 则不能再添加 */
char *select_num = "SELECT rule_priority, name, sip, dip, dport, flag FROM `authfree`";
ret = get_select_datebase_number(AUTHRECOVER_DATABASE_ID, auth_hdbc, "authfree", select_num, &num_sql, 6,
DB_DATA_INT_TYPE, sizeof(rule_priority), rule_priority,
DB_DATA_STRING_TYPE, strlen(name) + 1, name,
DB_DATA_INT_TYPE, sizeof(sip), sip,
DB_DATA_INT_TYPE, sizeof(dip), dip,
DB_DATA_INT_TYPE, sizeof(dport), dport,
DB_DATA_INT_TYPE, sizeof(flag), flag);
printf("num_sql = %d \n", num_sql);
printf("ret = %d \n", ret);
if(num_sql > RULE_MAX_NUM) {
/*添加失败*/
//disconnect_database(AUTHFREE_DATABASE_ID, authfree_hdbc); // ret_release记录日志
authfree_result->resultcode = RULE_ID_MAX;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
return;
}
/* 向authfree表中添加：未认证权限名称、内部源IP地址、目的IP地址、目的端口号 */
char *addfree_sql = "INSERT INTO `authfree` SET rule_priority = ?, name = ?, sip = ?, dip = ?, dport = ?, flag = ?";
ret_add = update_database(AUTHRECOVER_DATABASE_ID, auth_hdbc, DB_OP_INSERT, AUTHFREE_TABLE, addfree_sql, 6,
DB_DATA_INT_TYPE, sizeof(rule_priority), rule_priority,
DB_DATA_STRING_TYPE, strlen(name) + 1, name,
DB_DATA_INT_TYPE, sizeof(sip), sip,
DB_DATA_INT_TYPE, sizeof(dip), dip,
DB_DATA_INT_TYPE, sizeof(dport), dport,
DB_DATA_INT_TYPE, sizeof(flag), flag);
printf("the value of ret:%d\n", ret_add);
if(0 != ret_add) {
/*添加失败*/
//disconnect_database(AUTHFREE_DATABASE_ID, authfree_hdbc); // ret_release记录日志
authfree_result->resultcode = ADD_RULE_ERR;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
return;
}
//disconnect_database(AUTHFREE_DATABASE_ID, authfree_hdbc);
/*存未认证权限数数组*/
for(i = 0; i < RULE_MAX_NUM; i++) {
printf("the name is :%s\n", freeauth_array[i].name);
/*两个字符串相等 strcmp值为0*/
int a = strlen(freeauth_array[i].name);
printf("%d\n", a);
@ -140,7 +61,7 @@ void add_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &freeauth_array[i]);
memset(&freeauth_array[i], 0, sizeof(freeauth_configure_t));
freeauth_array[i].rule_priority = rule_priority;
strncpy(freeauth_array[i].name, name, 32);
strncpy(freeauth_array[i].name, name, 31);
freeauth_array[i].sip = sip;
freeauth_array[i].dip = dip;
freeauth_array[i].dport = dport;
@ -150,11 +71,12 @@ void add_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int
break;
}
}
/*打印数组内全部元素*/
printf("打印添加后的数组\n");
for(i = 0; i < RULE_MAX_NUM; i++)
{
freeauth_array[i].rule_priority;
printf("[%d %s %d %d %d %d %d]\n", freeauth_array[i].rule_priority, freeauth_array[i].name, freeauth_array[i].sip,
freeauth_array[i].dip, freeauth_array[i].dport, freeauth_array[i].dport, i);
}
@ -165,77 +87,324 @@ void add_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int
}
/*修改未认证权限*/
void mod_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int dport, int flag, authfree_result_t *authfree_result)
/*通过未认证权限name查询对应的序列号（优先级）*/
void get_priority_by_name(char *name, int *before)
{
//void *authfree_hdbc;
char *ret_sql = NULL;
int ret_mod;
int i;
for(i = 0; i < RULE_MAX_NUM; i++) {
/*两个字符串相等 strcmp值为0*/
if(0 == strcmp(freeauth_array[i].name, name)) {
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &freeauth_array[i]);
*before = freeauth_array[i].rule_priority;
printf("[%d %d]\n", *before, i);
break;
}
}
return;
}
/*移动未认证权限*/
void mov_authfree(char *name, int after, authfree_result_t *authfree_result)
{
int before_arry = 0;
int ret;
int num;
int i;
int temp;
freeauth_configure_t before_array[RULE_MAX_NUM] = {0};
if(NULL == authfree_result) {
return;
}
printf("开始连接数据库\n");
#if 0
/* 连接数据库 */
authfree_hdbc = connect_database(AUTHRECOVER_DATABASE_ID);
/*从未认证权限规则的数组中通过name 查询序列号*/
get_priority_by_name(name, &before_arry);
if(NULL == authfree_hdbc) {
printf("connetc failure\n");
return;
#if 0
/*序号的值对应指向未认证权限规则数组中的优先级*/
for(i = 0; i < RULE_MAX_NUM; i++)
{
rule_order[i] = freeauth_array[i].rule_priority;
}
/*长整型bigint 浮点型double 字符串character(10)*/
printf("authfree_hdbc = %p\n", authfree_hdbc);
#endif
/*建表*/
ret = create_database_table(AUTHRECOVER_DATABASE_ID, auth_hdbc, "authfree", "create table authfree(name character(32), sip bigint, dip bigint, dport bigint)");
printf("%d \n", ret);
for(i = 0; i < RULE_MAX_NUM; i++)
{
printf("order:%d\n", rule_order[i]);
}
#if 0
/*查询数据库是否存在该权限规则*/
char *select_sql = "SELECT name, sip, dip, dport FROM `authfree`WHERE name = ?";
ret_sql = select_datebase_by_number(AUTHFREE_DATABASE_ID, authfree_hdbc, "authfree", select_sql, 1, 0, &num, 1,
DB_DATA_STRING_TYPE, strlen(name) + 1, name);
printf("before:%d\n", before);
printf("after:%d\n", after);
/*比如说2移动到5前面*/
/*0 1 2 3 4 5 6 7 8 9*/
/*0 1 3 4 2 5 6 7 8 9*/
/*4的值变为2(after-1的值变为before), 同时2~5之间的值,也就是 3 4的值都减1*/
if(before < after)
{
rule_order[after - 1] = before;
printf("%d\n", rule_order[after - 1]);
for(i = (before + 1); i < after; i++)
{
rule_order[i - 1] = i;
}
if(NULL == ret_sql) {
/*未认证权限用户名不存在*/
disconnect_database(AUTHFREE_DATABASE_ID, authfree_hdbc);
authfree_result->resultcode = RULE_NOT_FOUNT;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
return;
} else {
for(i = 0; i < RULE_MAX_NUM; i++)
{
printf("order:%d\n", rule_order[i]);
}
}
/*5 before 移动到2 after前面*/
/*0 1 2 3 4 5 6 7 8 9*/
/*0 1 5 2 3 4 6 7 8 9*/
/*2变为5(after的值为before), 2到5之前的值，2、3、4的值都加1*/
else
{
rule_order[after] = before;
for(i = after; i < before; i++)
{
rule_order[i + 1] = i;
}
for(i = 0; i < RULE_MAX_NUM; i++)
{
printf("order:%d\n", rule_order[i]);
}
}
#endif
/*修改authfree表中内部源IP地址、目的IP地址、目的端口号 未认证权限名称不能修改 */
char *modfree_sql = "UPDATE `authfree` SET rule_priority = ?, sip = ?, dip = ?, dport = ? ,flag = ? WHERE name = ?";
ret_mod = update_database(AUTHRECOVER_DATABASE_ID, auth_hdbc, DB_OP_UPDATE, AUTHFREE_TABLE, modfree_sql, 6,
DB_DATA_INT_TYPE, sizeof(rule_priority), rule_priority,
DB_DATA_INT_TYPE, sizeof(sip), sip,
DB_DATA_INT_TYPE, sizeof(dip), dip,
DB_DATA_INT_TYPE, sizeof(dport), dport,
DB_DATA_INT_TYPE, sizeof(flag), flag,
DB_DATA_STRING_TYPE, strlen(name) + 1, name);
printf("the value of ret:%d\n", ret_mod);
/*从未认证权限规则的数组中通过name 查询序列号*/
get_priority_by_name(name, &before_arry);
if(0 != ret_mod) {
/*修改失败*/
//disconnect_database(AUTHFREE_DATABASE_ID, authfree_hdbc); // ret_release记录日志
authfree_result->resultcode = MOD_RULE_ERR;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
int before = before_arry - 1;
printf("before:%d\n", before);
printf("after:%d\n", after);
/*把要移动的数组copy一份出来*/
for(i = 0; i < RULE_MAX_NUM; i++)
{
before_array[i].rule_priority = freeauth_array[i].rule_priority;
strncpy(before_array[i].name, freeauth_array[i].name, 31);
before_array[i].rule_priority = freeauth_array[i].rule_priority;
before_array[i].sip = freeauth_array[i].sip;
before_array[i].dip = freeauth_array[i].dip;
before_array[i].dport = freeauth_array[i].dport;
before_array[i].flag = freeauth_array[i].flag;
}
for(i = 0; i < RULE_MAX_NUM; i++)
{
printf("[%d %s %d %d %d %d %d]\n", before_array[i].rule_priority, before_array[i].name, before_array[i].sip,
before_array[i].dip, before_array[i].dport, before_array[i].dport, i);
}
/*比如说2移动到5前面*/
/*0 1 2 3 4 5 6 7 8 9*/
/*0 1 3 4 2 5 6 7 8 9*/
/*4的值变为2(after-1的值变为before), 同时2~5之间的值,也就是 3 4的值都减1*/
if(before < after)
{
/*after-1 change before*/
//freeauth_array[after - 1].rule_priority = after;
strncpy(freeauth_array[after - 1].name, before_array[before].name, 31);
freeauth_array[after - 1].sip = before_array[before].sip;
freeauth_array[after - 1].dip = before_array[before].dip;
freeauth_array[after - 1].dport = before_array[before].dport;
freeauth_array[after - 1].flag = before_array[before].flag;
for(i = (before + 1); i < after; i++)
{
//freeauth_array[i - 1].rule_priority = i;
strncpy(freeauth_array[i - 1].name, before_array[i].name, 31);
freeauth_array[i - 1].sip = before_array[i].sip;
freeauth_array[i - 1].dip = before_array[i].dip;
freeauth_array[i - 1].dport = before_array[i].dport;
freeauth_array[i - 1].flag = before_array[i].flag;
}
printf("打印移动后的数据\n");
for(i = 0; i < RULE_MAX_NUM; i++)
{
printf("[%s %d %d %d %d %d]\n", freeauth_array[i].name, freeauth_array[i].sip,
freeauth_array[i].dip, freeauth_array[i].dport, freeauth_array[i].dport, i);
}
}
/*5 before 移动到2 after前面*/
/*0 1 2 3 4 5 6 7 8 9*/
/*0 1 5 2 3 4 6 7 8 9*/
/*2变为5(after的值为before), 2到5之前的值，2、3、4的值都加1*/
else
{
/*after change before*/
//freeauth_array[after].rule_priority = before - 1;
strncpy(freeauth_array[after].name, before_array[before].name, 31);
freeauth_array[after].sip = before_array[before].sip;
freeauth_array[after].dip = before_array[before].dip;
freeauth_array[after].dport = before_array[before].dport;
freeauth_array[after].flag = before_array[before].flag;
for(i = after; i < before; i++)
{
//freeauth_array[i + 1].rule_priority = i + 2;
strncpy(freeauth_array[i + 1].name, before_array[i].name, 31);
freeauth_array[i + 1].sip = before_array[i].sip;
freeauth_array[i + 1].dip = before_array[i].dip;
freeauth_array[i + 1].dport = before_array[i].dport;
freeauth_array[i + 1].flag = before_array[i].flag;
}
printf("打印移动后的数据\n");
for(i = 0; i < RULE_MAX_NUM; i++)
{
printf("[ %s %d %d %d %d %d]\n", freeauth_array[i].name, freeauth_array[i].sip,
freeauth_array[i].dip, freeauth_array[i].dport, freeauth_array[i].dport, i);
}
}
/*修改成功*/
authfree_result->resultcode = MOV_RULE_SUCCESS;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
}
/*删除未认证权限*/
void del_authfree(char *name, authfree_result_t *authfree_result)
{
int i;
freeauth_configure_t del_array[RULE_MAX_NUM] = {0};
if(NULL == authfree_result) {
return;
}
//disconnect_database(AUTHFREE_DATABASE_ID, authfree_hdbc);
/*把要移动的数组copy一份出来到临时的数组*/
for(i = 0; i < RULE_MAX_NUM; i++)
{
del_array[i].rule_priority = freeauth_array[i].rule_priority;
strncpy(del_array[i].name, freeauth_array[i].name, 31);
del_array[i].rule_priority = freeauth_array[i].rule_priority;
del_array[i].sip = freeauth_array[i].sip;
del_array[i].dip = freeauth_array[i].dip;
del_array[i].dport = freeauth_array[i].dport;
del_array[i].flag = freeauth_array[i].flag;
}
printf("复制到临时的数组\n");
for(i = 0; i < RULE_MAX_NUM; i++)
{
printf("[%d %s %d %d %d %d %d]\n", del_array[i].rule_priority, del_array[i].name, del_array[i].sip,
del_array[i].dip, del_array[i].dport, del_array[i].dport, i);
}
#if 0
/*修改对应未认证权限数数组*/
for(i = 0; i < RULE_MAX_NUM; i++) {
/*两个字符串相等 strcmp值为0*/
if(0 == strcmp(freeauth_array[i].name, name)) {
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &freeauth_array[i]);
memset(&freeauth_array[i], 0, sizeof(freeauth_configure_t));
/*删除之后，数组里每一位都往前排序 比如之前是4的 现在排到3*/
for(i =(i + 1); i < RULE_MAX_NUM; i++){
freeauth_array[i-1].rule_priority = i;
strncpy(freeauth_array[i-1].name, freeauth_array[i].name, 31);
freeauth_array[i-1].sip = freeauth_array[i].sip;
freeauth_array[i-1].dip = freeauth_array[i].dip;
freeauth_array[i-1].dport = freeauth_array[i].dport;
freeauth_array[i-1].flag = freeauth_array[i].flag;
printf("[%d %s %d %d %d %d %d]\n", freeauth_array[i].rule_priority, freeauth_array[i].name, freeauth_array[i].sip,
freeauth_array[i].dip, freeauth_array[i].dport, freeauth_array[i].dport, i);
}
}
}
#endif
/*删除对应未认证权限数数组*/
for(i = 0; i < RULE_MAX_NUM; i++) {
/*两个字符串相等 strcmp值为0*/
if(0 == strcmp(del_array[i].name, name)) {
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &del_array[i]);
memset(&del_array[i], 0, sizeof(freeauth_configure_t));
printf("[%d %s %d %d %d %d %d]\n", del_array[i].rule_priority, del_array[i].name, del_array[i].sip,
del_array[i].dip, del_array[i].dport, del_array[i].dport, i);
}
}
printf("打印删除后临时的数组\n");
for(i = 0; i < RULE_MAX_NUM; i++)
{
printf("[%d %s %d %d %d %d %d]\n", del_array[i].rule_priority, del_array[i].name, del_array[i].sip,
del_array[i].dip, del_array[i].dport, del_array[i].dport, i);
}
for(i = 0; i < RULE_MAX_NUM; i++)
{
memset(&freeauth_array[i], 0, sizeof(freeauth_configure_t));
}
for(i = 0; i < RULE_MAX_NUM; i++)
{
/*删除数组依次读取数据，有数据的时候按顺序存入全局变量中*/
if(0 != strlen(del_array[i].name))
{
for(int j = 0; j < RULE_MAX_NUM; j++)
{
if(0 == strlen(freeauth_array[j].name))
{
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, j, &freeauth_array[j]);
memset(&freeauth_array[j], 0, sizeof(freeauth_configure_t));
freeauth_array[j].rule_priority = del_array[i].rule_priority;
strncpy(freeauth_array[j].name, del_array[i].name, 31);
freeauth_array[j].sip = del_array[i].sip;
freeauth_array[j].dip = del_array[i].dip;
freeauth_array[j].dport = del_array[i].dport;
freeauth_array[j].flag = del_array[i].flag;
printf("[%d %s %d %d %d %d %d]\n", freeauth_array[j].rule_priority, freeauth_array[j].name, freeauth_array[j].sip,
freeauth_array[j].dip, freeauth_array[j].dport, freeauth_array[j].dport, j);
break;
}
}
}
}
/*打印删除后的数组*/
printf("打印删除后的数据\n");
for(i = 0; i < RULE_MAX_NUM; i++) {
printf("[%d %s %d %d %d %d %d]\n", freeauth_array[i].rule_priority, freeauth_array[i].name, freeauth_array[i].sip,
freeauth_array[i].dip, freeauth_array[i].dport, freeauth_array[i].dport, i);
}
/*删除成功*/
authfree_result->resultcode = DEL_RUL_OK;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
}
/*修改未认证权限规则*/
void mod_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int dport, int flag, authfree_result_t *authfree_result)
{
int i;
if(NULL == authfree_result) {
return;
}
if(is_rule_full()) {
authfree_result->resultcode = RULE_FULL;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
return;
}
/*修改对应未认证权限数数组*/
for(i = 0; i < RULE_MAX_NUM; i++) {
/*两个字符串相等 strcmp值为0*/
if(0 == strcmp(freeauth_array[i].name, name)) {
@ -251,10 +420,10 @@ void mod_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int
}
}
/*打印数组内全部元素*/
for(i = 0; i < RULE_MAX_NUM; i++)
{
printf("[%d %s %d %d %d %d %d]\n", freeauth_array[i].rule_priority, freeauth_array[i].name, freeauth_array[i].sip,
for(i = 0; i < RULE_MAX_NUM; i++) {
printf("[%d %s %d %d %d %d %d]\n", freeauth_array[i].rule_priority, freeauth_array[i].name, freeauth_array[i].sip,
freeauth_array[i].dip, freeauth_array[i].dport, freeauth_array[i].dport, i);
}
@ -262,87 +431,3 @@ void mod_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int
authfree_result->resultcode = MOD_RULE_OK;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
}
/*删除未认证权限*/
void del_authfree(char *name, authfree_result_t *authfree_result)
{
//void *authfree_hdbc;
char *ret_sql = NULL;
int ret_del;
int ret;
int num;
int i;
if(NULL == authfree_result) {
return;
}
#if 0
/* 连接数据库 */
authfree_hdbc = connect_database(AUTHFREE_DATABASE_ID);
if(NULL == authfree_hdbc) {
printf("connetc failure\n");
return;
}
/*长整型bigint 浮点型double 字符串character(10)*/
printf("authfree_hdbc = %p\n", authfree_hdbc);
#endif
/*建表*/
ret = create_database_table(AUTHRECOVER_DATABASE_ID, auth_hdbc, "authfree", "create table authfree(name character(32), sip bigint, dip bigint, dport bigint)");
printf("%d \n", ret);
#if 0
/*查询数据库是否存在该权限规则*/
char *select_sql = "SELECT rule_priority, name, sip, dip, dport, flag FROM `authfree`WHERE name = ?";
ret_sql = select_datebase_by_number(AUTHFREE_DATABASE_ID, authfree_hdbc, "authfree", select_sql, 1, 0, &num, 1,
DB_DATA_STRING_TYPE, strlen(name) + 1, name);
if(NULL == ret_sql) {
/*未认证权限用户名不存在*/
authfree_result->resultcode = RULE_NOT_FOUNT;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
return;
} else {
}
#endif
/*删除authfree表中未认证权限名称、内部源IP地址、目的IP地址、目的端口号 */
char *delfree_sql = "DELETE FROM authfree WHERE name = ?";
ret_del = update_database(AUTHRECOVER_DATABASE_ID, auth_hdbc, DB_OP_DEL, AUTHFREE_TABLE, delfree_sql, 1,
DB_DATA_STRING_TYPE, strlen(name) + 1, name);
printf("the value of ret:%d\n", ret_del);
if(0 != ret_del) {
//disconnect_database(AUTHFREE_DATABASE_ID, authfree_hdbc); // ret_release记录日志
authfree_result->resultcode = DEL_RULE_ERR; /*删除失败*/
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
return;
}
//disconnect_database(AUTHFREE_DATABASE_ID, authfree_hdbc);
/*修改对应未认证权限数数组*/
for(i = 0; i < RULE_MAX_NUM; i++) {
/*两个字符串相等 strcmp值为0*/
if(0 == strcmp(freeauth_array[i].name, name)) {
printf("%s(%d) freeauth_array[%d] = %p\n", __FUNCTION__, __LINE__, i, &freeauth_array[i]);
memset(&freeauth_array[i], 0, sizeof(freeauth_configure_t));
printf("[%d %s %d %d %d %d %d]\n", freeauth_array[i].rule_priority, freeauth_array[i].name, freeauth_array[i].sip,
freeauth_array[i].dip, freeauth_array[i].dport, freeauth_array[i].dport, i);
break;
}
}
/*删除成功*/
authfree_result->resultcode = DEL_RUL_OK;
authfree_result->message = get_sql_ret_message(authfree_result->resultcode);
}

2
Platform/user/configm/config-server/web_config/config-adm/user_authpara.c
View File

@ -46,6 +46,7 @@ void mod_authpara(int port, int timehorizon, int failcount, int locktime, int ag
printf("authpara_hdbc = %p\n", authpara_hdbc);
#endif
#if 0
/*建表*/
ret = create_database_table(AUTHRECOVER_DATABASE_ID, auth_hdbc, "authparas", "create table authparas(port bigint, timehorizon bigint, failcount bigint, locktime bigint, aging_time bigint)");
printf("%d \n",ret);
@ -79,6 +80,7 @@ void mod_authpara(int port, int timehorizon, int failcount, int locktime, int ag
}
//disconnect_database(AUTHPARA_DATABASE_ID , authpara_hdbc);
#endif
/*存全局变量*/
auth_para->port = port;

18
Platform/user/configm/config-server/web_config/include/user_authfree.h
View File

@ -22,16 +22,28 @@ typedef enum {
DEL_RULE_ERR = 7,
RULE_ID_MAX = 8,
RULE_FULL = 9,
MOV_RULE_SUCCESS = 10,
GET_RELE_SUCCESS = 11,
CODE_MAX,
} SQL_RET_CODE;
static char *get_sql_ret_message(SQL_RET_CODE code);
static int is_rule_full(void);
/*增加未认证权限规则*/
void add_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int dport, int flag, authfree_result_t *authfree_result);
/*修改未认证权限*/
void mod_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int dport, int flag, authfree_result_t *authfree_result);
/*通过未认证权限name查询对应的序列号（优先级）*/
void get_priority_by_name(char *name, int *before);
/*移动未认证权限*/
void mov_authfree(char *name, int after, authfree_result_t *authfree_result);
/*删除未认证权限*/
void del_authfree(char *name, authfree_result_t *authfree_result);
void del_authfree(char *name, authfree_result_t *authfree_result);
/*修改未认证权限规则*/
void mod_authfree(int rule_priority, char *name, uint32_t sip, uint32_t dip, int dport, int flag, authfree_result_t *authfree_result);
#endif

25
libs/src/lighttpd-1.4.51/src/mod_webm.c
View File

@ -23,7 +23,7 @@ typedef enum { WEBM_HANDLE_INVALID_INDEX = -1,
WEBM_HANDLE_LOGIN,
WEBM_HANDLE_HOMEPAGE,
/* <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ҳ<EFBFBD><EFBFBD>ȡ<EFBFBD><EFBFBD>չʾ<EFBFBD><EFBFBD>case<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ܿ<EFBFBD><EFBFBD><EFBFBD>ͨ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݿ<EFBFBD><EFBFBD>ѯ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȷŵ<EFBFBD>һ<EFBFBD><EFBFBD> */
/* ������ҳ��ȡ��չʾ��case�������������ܿ���ͨ�����ݿ��Ñ?�������ȷŵ�һ�� */
WEBM_HANDLE_CONFIG_LIST_GROUP,
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>ص<EFBFBD>case */
@ -47,8 +47,10 @@ typedef enum { WEBM_HANDLE_INVALID_INDEX = -1,
WEBM_HANDLE_CONFIG_MOD_AUTHPARA,
WEBM_HANDLE_CONFIG_ADD_AUTHRULE,
WEBM_HANDLE_CONFIG_MOV_AUTHRULE,
WEBM_HANDLE_CONFIG_DEL_AUTHRULE,
WEBM_HANDLE_CONFIG_MOD_AUTHRULE,
WEBM_HANDLE_CONFIG_DEL_AUTHRULE
WEBM_HANDLE_CONFIG_GET_AUTHRULE
} webm_handle_index;
typedef struct _webm_config_st
@ -227,7 +229,7 @@ extern int webm_config_send_proc(server *srv, uint32_t config_type, uint64 confg
}, \
\
{\
WEBM_HANDLE_CONFIG_MOD_AUTHRULE, \
WEBM_HANDLE_CONFIG_MOV_AUTHRULE, \
"/FSG-GF/userauth-rule-mod", \
CM_CONFIG_SET, \
AUTHFREE_CONFIG, \
@ -240,6 +242,23 @@ extern int webm_config_send_proc(server *srv, uint32_t config_type, uint64 confg
CM_CONFIG_SET, \
AUTHFREE_CONFIG, \
webm_config_send_proc \
}, \
\
\
{\
WEBM_HANDLE_CONFIG_MOD_AUTHRULE, \
"/FSG-GF/userauth-rule-mod", \
3, \
AUTHFREE_CONFIG, \
webm_config_send_proc \
} ,\
\
{\
WEBM_HANDLE_CONFIG_GET_AUTHRULE, \
"/FSG-GF/userauth-rule-get", \
3, \
AUTHFREE_CONFIG, \
webm_config_send_proc \
} \
\
}