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

Merge remote-tracking branch 'origin/master' 

# Conflicts:
#	srcs/open_dhcp/query.cpp
This commit is contained in:
huangxin 2022-12-07 16:01:56 +08:00
parent 548787003f 6ec5f520a2
commit 3790f66ace
2 changed files with 187 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
srcs/open_dhcp/opendhcpd.cpp
View File

@ -40,6 +40,7 @@ using namespace std;
#include "opendhcpd.h"
#include "dhcpd.h"
#include "task_manager.h"
#include "user_errno.h"
void on_system_exit(void *p);
//Global Variables
@ -55,6 +56,7 @@ data71 lump;
bool kRunning = true;
dhcpMap dhcpCache;
char serviceName[] = "OpenDHCPServer";
int ERR_PARAM;
//char tempbuff[512] = "";
//char logBuff[256];
//char extbuff[256] = "";
@ -3051,6 +3053,7 @@ void addDHCPRange(char *dp) {
(range->rangeEnd >= rs && range->rangeEnd <= re)) {
sprintf(logBuff, "Warning: DHCP Range %s overlaps with another range, ignored", dp);
logDHCPMess(logBuff, 1);
ERR_PARAM = ERR_ITEM_EXISTS;
return;
}
}
@ -3074,6 +3077,7 @@ void addDHCPRange(char *dp) {
sprintf(logBuff, "DHCP Ranges Load, Memory Allocation Error");
logDHCPMess(logBuff, 1);
ERR_PARAM = ERR_MALLOC_MEMORY;
return;
}
}

186
srcs/open_dhcp/query.cpp
View File

@ -28,6 +28,7 @@ extern data2 cfig;
extern bool kRunning;
extern dhcpMap dhcpCache;
extern time_t t;
extern int ERR_PARAM;
static int dhcp_get_user_info(data19 *req, const char *pRequest) {
char logBuff[512];
@ -216,6 +217,9 @@ static void add_options(OBJ_DHCP_RNG pRange, data20 *optionData) {
//dhcp_range
addDHCPRange(pRange.rangAddr);
if(ERR_PARAM != ERR_SUCCESS){
return;
}
if (strlen(pRange.subnet) != 0) {
strcpy(value, pRange.subnet);
@ -259,6 +263,7 @@ static int add_dhcpd_rangeset(data19 *req, const char *pRequest) {
cJSON *pRspRoot;
cJSON *pExpandArray;
ERR_PARAM = ERR_SUCCESS;
dzlog_debug("Input: %s\n", pRequest);
if (pRequest == nullptr || strlen(pRequest) == 0) {
@ -309,8 +314,6 @@ static int add_dhcpd_rangeset(data19 *req, const char *pRequest) {
}
cJSON_AddStringToObject(pEx_range, "dhcpRange", pdhcp_range->valuestring);
cJSON_AddNumberToObject(pEx_range, "status", ERR_SUCCESS);
cJSON_AddStringToObject(pEx_range, "message", getErrorEnumDesc(ERR_SUCCESS));
cJSON *psubnet_mask = cJSON_GetObjectItem(pItem, "netmask");
cJSON *pdomain_server = cJSON_GetObjectItem(pItem, "domainServer");
@ -345,6 +348,12 @@ static int add_dhcpd_rangeset(data19 *req, const char *pRequest) {
cfig.rangeSet[optionData.rangeSetInd].active = true;
add_options(pRange, &optionData);
if(ERR_PARAM != ERR_SUCCESS){
cJSON_AddNumberToObject(pEx_range, "status", ERR_PARAM);
cJSON_AddStringToObject(pEx_range, "message", getErrorEnumDesc(ERR_PARAM));
cJSON_AddItemToArray(pExpandArray, pEx_range);
break;
}
if (optionData.optionSize > 3) {
options = (MYBYTE *)calloc(1, optionData.optionSize);
@ -359,6 +368,8 @@ static int add_dhcpd_rangeset(data19 *req, const char *pRequest) {
}
cfig.rangeCount = (char)(m + 1);
cJSON_AddNumberToObject(pEx_range, "status", ERR_SUCCESS);
cJSON_AddStringToObject(pEx_range, "message", getErrorEnumDesc(ERR_SUCCESS));
cJSON_AddItemToArray(pExpandArray, pEx_range);
}
@ -374,6 +385,122 @@ static int add_dhcpd_rangeset(data19 *req, const char *pRequest) {
return ERR_SUCCESS;
}
static int delete_dhcpd_rangeset(data19 *req, const char *pRequest){
char logBuff[512];
const char *pStrContent;
char *fp;
cJSON *pRspRoot;
cJSON *pdelArray;
dzlog_debug("Input: %s\n", pRequest);
if (pRequest == nullptr || strlen(pRequest) == 0) {
sprintf(logBuff, "Requeset Json");
logDHCPMess(logBuff, 1);
return ERR_INPUT_PARAMS;
}
pStrContent = proto_decode_context(pRequest, nullptr, nullptr);
if (pStrContent == nullptr) {
sprintf(logBuff, "Requeset Json error %s", pRequest);
logDHCPMess(logBuff, 1);
return ERR_PROTO_DECODE;
}
cJSON *pRoot = cJSON_Parse(pStrContent);
free((void *)pStrContent);
if (!pRoot) {
return ERR_JSON_PRASE_OBJ;
}
cJSON *pdhcp_range = cJSON_GetObjectItem(pRoot, "dhcpRange");
req->memSize = (int)(2048 + (135 * dhcpCache.size()) + (cfig.dhcpSize * 26));
req->dp = (char *)calloc(1, req->memSize);
if (!req->dp) {
sprintf(logBuff, "Memory Error");
logDHCPMess(logBuff, 1);
cJSON_Delete(pRoot);
return ERR_MALLOC_MEMORY;
}
fp = req->dp;
pRspRoot = cJSON_CreateObject();
pdelArray = cJSON_CreateArray();
cJSON_AddItemToObject(pRspRoot, "rangeSet", pdelArray);
for(int i = 0; i < cJSON_GetArraySize(pdhcp_range); i++){
cJSON *pdelRange = cJSON_GetArrayItem(pdhcp_range, i);
cJSON *pdel_Item = cJSON_CreateObject();
char del_range[256];
bool deleted_flag = false;
if(!pdelRange){
continue;
}
strcpy(del_range, pdelRange->valuestring);
MYDWORD st_addr;
MYDWORD en_addr;
char start[128];
char end[128];
mySplit(start, end, del_range, '-');
st_addr = htonl(inet_addr(start));
en_addr = htonl(inet_addr(end));
cJSON_AddStringToObject(pdel_Item, "dhcpRange", pdelRange->valuestring);
if(st_addr && en_addr && st_addr <= en_addr){
MYBYTE m = 0;
for (; m < cfig.rangeCount && cfig.dhcpRanges[m].rangeStart; m++) {
if(!deleted_flag){
if((st_addr == cfig.dhcpRanges[m].rangeStart) && (en_addr == cfig.dhcpRanges[m].rangeEnd)){
deleted_flag = true;
if(m == cfig.rangeCount-1){
memset(&cfig.dhcpRanges[m], 0, sizeof(struct data19));
}
continue;
}else if(st_addr == cfig.dhcpRanges[m].rangeStart||en_addr == cfig.dhcpRanges[m].rangeEnd){
deleted_flag = false;
break;
}
}else{
memcpy(&(cfig.dhcpRanges[m-1]), &(cfig.dhcpRanges[m]), sizeof(struct data19));
}
}
}else{
cJSON_AddNumberToObject(pdel_Item, "status", ERR_INPUT_PARAMS);
cJSON_AddStringToObject(pdel_Item, "message", getErrorEnumDesc(ERR_INPUT_PARAMS));
cJSON_AddItemToArray(pdelArray, pdel_Item);
break;
}
if(deleted_flag){
cfig.rangeCount--;
}else{
cJSON_AddNumberToObject(pdel_Item, "status", ERR_INPUT_PARAMS);
cJSON_AddStringToObject(pdel_Item, "message", getErrorEnumDesc(ERR_INPUT_PARAMS));
cJSON_AddItemToArray(pdelArray, pdel_Item);
break;
}
cJSON_AddNumberToObject(pdel_Item, "status", ERR_SUCCESS);
cJSON_AddStringToObject(pdel_Item, "message", getErrorEnumDesc(ERR_SUCCESS));
cJSON_AddItemToArray(pdelArray, pdel_Item);
}
const char *pStrPro = proto_create_new(pRspRoot, 200);
fp += sprintf(fp, "%s", pStrPro);
cJSON_Delete(pRoot);
req->bytes = (int)(fp - req->dp);
free((void*)pStrPro);
return ERR_SUCCESS;
}
#pragma clang diagnostic push
#pragma ide diagnostic ignored "cert-err34-c"
int getHwAddr(char *buff, char *mac) {
@ -609,7 +736,7 @@ static void opendhcp_http_get_alluser(http_request *request, hw_http_response *r
hw_http_response_send(response, req, response_complete);
}
static void opendhcp_http_expand_rangeset(http_request *request, hw_http_response *response, void *UNUSED(user_data)) {
static void opendhcp_http_add_rangeset(http_request *request, hw_http_response *response, void *UNUSED(user_data)) {
hw_string status_code;
hw_string content_type_name;
hw_string content_type_value;
@ -657,6 +784,54 @@ static void opendhcp_http_expand_rangeset(http_request *request, hw_http_respons
hw_http_response_send(response, req, response_complete);
}
static void opendhcp_http_delete_rangeset(http_request *request, hw_http_response *response, void *UNUSED(user_data)) {
hw_string status_code;
hw_string content_type_name;
hw_string content_type_value;
hw_string body;
hw_string keep_alive_name;
hw_string keep_alive_value;
int ret;
auto *req = (data19 *)malloc(sizeof(struct data19));
if (req == nullptr) {
hw_http_response_send_error(response, HTTP_STATUS_500, "memory error");
return;
}
if (request->method != HW_HTTP_POST) {
hw_http_response_send_error(response, HTTP_STATUS_405, HTTP_STATUS_405);
return;
}
memset(req, 0, sizeof(struct data19));
SETSTRING(content_type_name, "Content-Type");
SETSTRING(content_type_value, "application/json");
hw_set_response_header(response, &content_type_name, &content_type_value);
SETSTRING(status_code, HTTP_STATUS_200);
ret = delete_dhcpd_rangeset(req, request->body->value);
if (ret != ERR_SUCCESS) {
proto_response_error(response, 500, HTTP_STATUS_500, ret);
return;
}
SETSTRING(body, req->dp);
hw_set_body(response, &body);
hw_set_response_status_code(response, &status_code);
if (request->keep_alive) {
SETSTRING(keep_alive_name, "Connection");
SETSTRING(keep_alive_value, "close");
hw_set_response_header(response, &keep_alive_name, &keep_alive_value);
} else {
hw_set_http_version(response, 1, 0);
}
hw_http_response_send(response, req, response_complete);
}
/**
* 添加配置文件监听接口
* @return
@ -686,7 +861,12 @@ void opendhcp_init_http_server() {
hw_http_add_route("/", opendhcp_http_info, nullptr);
hw_http_add_route("dhcp/info/getuser", opendhcp_http_get_userinfo, nullptr);
hw_http_add_route("dhcp/info/allusers", opendhcp_http_get_alluser, nullptr);
<<<<<<< HEAD
hw_http_add_route("dhcp/config/rangeset", opendhcp_http_expand_rangeset, nullptr);
=======
hw_http_add_route("dhcp/config/rangeset", opendhcp_http_add_rangeset, nullptr);
hw_http_add_route("dhcp/delete/rangeset", opendhcp_http_delete_rangeset, nullptr);
>>>>>>> origin/master
added = TRUE;
}
}