/******************************************************************************
* Copyright (c) 2015-2017 TP-L
ink Technologies CO.,LTD.
*
* �ļ�����: chm_ipaddr_manager.c
* �� ��: 1.0
* ժ Ҫ: ���������豸IP��ַ
* �� ��: q
ingbo<q
ingbo@tp-l
ink.net>
* ����ʱ��: 2015-11-06
******************************************************************************/
#
include <stdio.h>
#
include <stdlib.h>
#
include <str
ing.h>
#
include <unistd.h>
#
include <sys/types.h>
#
include <sys/socket.h>
#
include <net
inet/
in.h>
#
include <arpa/
inet.h>
#
include <sys/times.h>
#
include <time.h>
#
include <net/ethernet.h>
#
include <l
inux/if_ether.h>
#
include <net/if_arp.h>
#
include "tp_timer.h"
#
include "comm.h"
#
include "raw_sock.h"
#
include "arp.h"
#
include "api.h"
#
include "protocol.h"
#
include "chm_default.h"
#
include "chm_ubus.h"
#
include "chm_common.h"
#
include "chm_ipaddr_manager.h"
#
include "chm_dev_manager.h"
#
include "chm_dbg.h"
#
include "recv_center.h"
/* IP��鳬ʱʱ�� 300ms */
#def
ine IP_CHECK_TIMEOUT 300 * 1000
/*!<local
node��ubus���ø��£��˻���������g_
node_buf{local_
node/count/
node_list} */
static pthread_mutex_t timer_lock = PTHREAD_MUTEX_
INITIALIZER;
/*!<����ip��ͻ��Ϣ */
pthread_mutex_t ipcnflct
info_lock = PTHREAD_MUTEX_
INITIALIZER;
pthread_cond_t ipcnflct
info_cond = PTHREAD_COND_
INITIALIZER;
int local
node_freshed = 1;
/* ��㻺�棬��¼�����п��ýڵ��IP��MAC��ַ��Ϣ */
NODE_BUF g_
node_buf[MAX_NETIF_NUM];
static RAW_SOCK g_raw_arp[MAX_NETIF_NUM];
/****************************************************************************
* Function : get_
node_localhost
* Description: ��ñ�����ǰʵ�ʵ�IP�����������MAC��ַ
*
Input : local : �����豸�����ṹָ��
* Output : N/A
* Return : ���ز������
****************************************************************************/
CHM_STATUS get_
node_localhost(
int ifidx, NET_
NODE *local)
{
char ip_str[STR_IP_LEN] = {0};
char mask_str[STR_IP_LEN] = {0};
char mac_str[STR_MAC_LEN] = {0};
int32 ret = CHM_STATUS_ERROR;
if (ifidx < 0 || MAX_NETIF_NUM <= ifidx || !local)
{
CHM_DPR
INTF(MSG_ERROR, "
invalid argument,
node %p, ifidx %d\n", local, ifidx);
return CHM_STATUS_ARGS_
INVALID;
}
if (!strlen(g_netif_
info[ifidx].ifname))
{
CHM_DPR
INTF(MSG_NOTICE, "eth %d not used\n", ifidx);
return CHM_STATUS_ERROR;
}
ret = get_local_ipaddr(g_netif_
info[ifidx].ifname, ip_str);
if (ret != OK)
{
strncpy(ip_str, g_netif_
info[ifidx].ip, STR_IP_LEN);
CHM_DPR
INTF(MSG_NOTICE, "get local ip from g_netifd_
info, ip = %s\n", ip_str);
}
else
{
strncpy(g_netif_
info[ifidx].ip, ip_str, STR_IP_LEN);
CHM_DPR
INTF(MSG_NOTICE, "g_netifd_
info, ip = %s\n", ip_str);
}
IPv4_str
ing2IPv4_dec(ip_str, &local->ip);
ret = get_local_netmask(g_netif_
info[ifidx].ifname, mask_str);
if (ret != OK)
{
strncpy(mask_str, g_netif_
info[ifidx].netmask, STR_IP_LEN);
CHM_DPR
INTF(MSG_NOTICE, "get local netmask from g_netifd_
info, mask = %s\n", mask_str);
}
else
{
strncpy(g_netif_
info[ifidx].netmask, mask_str, STR_IP_LEN);
CHM_DPR
INTF(MSG_NOTICE, "g_netifd_
info, mask = %s\n", mask_str);
}
IPv4_str
ing2IPv4_dec(mask_str, &local->mask);
ret = get_local_macaddr(g_netif_
info[ifidx].ifname, mac_str);
if (ret != OK)
{
CHM_DPR
INTF(MSG_NOTICE, "get local macaddr error\n");
return CHM_STATUS_ERROR;
}
mac_str
ing2mac_hex(mac_str, local->mac_hex);
return CHM_STATUS_OK;
}
/****************************************************************************
* Function : f
ind_
node_buf_by_ip_addr
* Description: ��ѯָ��IP��ַ�Ƿ��ڽ�㻺����
*
Input : ip : ָ��IP��ַ��ʮ������ʽ�������ֽ���
* Output : N/A
* Return : �ڻ����з��ض�Ӧ�����±꣬����-1
****************************************************************************/
int32 f
ind_
node_buf_by_ip_addr(
int ifidx, u_
int32 ip)
{
int32 id = -1;
u_
int32 i = 0;
if (ifidx < 0 || MAX_NETIF_NUM <= ifidx)
{
return -1;
}
for (i = 0; i < g_
node_buf[ifidx].count; i++)
{
if (g_
node_buf[ifidx].
node_list[i].
node.ip == ip)
{
id = i;
break;
}
}
return id;
}
/****************************************************************************
* Function : ip_address_allocate
* Description: ��ڵ㻺��������õĽڵ�
*
Input : ����IP(�������IP��С�ڸ�IP��ַ)��IP��ַָ��
* Output : N/A
* Return : �ɹ�����
node_buf�±꣬����-1
****************************************************************************/
int32 ip_address_allocate(
int ifidx, u_
int32 base, u_
int32 *ip)
{
struct
in_addr
in;
char ip_str[MAX_IP_STR_LEN] = {0};
char gateway_str[MAX_IP_STR_LEN] = {0};
int32 ret = -1;
int32 id = -1;
u_
int32 i = 0;
u_
int32 j = 0;
DEVICE_CONFIG *device = NULL;
if (!ip)
{
CHM_DPR
INTF(MSG_ERROR, "
invalid argument\n");
return -1;
}
for (i = 0; i < g_
node_buf[ifidx].count; i++)
{
if ((g_
node_buf[ifidx].
node_list[i].
node.ip >= base))
{
break;
}
}
/* ��ȡNVR�����ص�ַ */
ret = get_local_gateway(ifidx, gateway_str);
if (ret != OK)
{
CHM_DPR
INTF(MSG_DEBUG, "get local gateway failed.\n");
gateway_str[0] = '\0';
}
for (j = 0; j < g_
node_buf[ifidx].count; j++)
{
i = i % g_
node_buf[ifidx].count;
if (!g_
node_buf[ifidx].
node_list[i].flag)
{
memset(&
in, 0, sizeof(
in));
in.s_addr = htonl(g_
node_buf[ifidx].
node_list[i].
node.ip);
inet_ntop(AF_
INET, &
in, ip_str, sizeof(ip_str));
/* ������IPC��IP��ַ��NVR��������ͬ */
if (!strcmp(gateway_str, ip_str))
{
i++;
cont
inue;
}
device = device_f
ind_
in_device_list(SRH_KEY_TYPE_IP, ip_str);
if (device)
{
g_
node_buf[ifidx].
node_list[i].flag |=
NODE_IP_ALLOCED;
i++;
cont
inue;
}
ret = device_f
ind_
in_channel_list(SRH_KEY_TYPE_IP, ip_str);
if (ret < 0)
{
id = i;
*ip = g_
node_buf[ifidx].
node_list[i].
node.ip;
g_
node_buf[ifidx].
node_list[i].flag |=
NODE_IP_ALLOCED;
break;
}
}
i++;
}
return id;
}
/****************************************************************************
* Function : ip_address_clear_flag
* Description: ���flag
*
Input : mask
* Output : N/A
* Return : �ɹ�����
node_buf�±꣬����-1
****************************************************************************/
void ip_address_clear_flag(
int ifidx, u_
int32 mask)
{
u_
int32 i = 0;
for (i = 0; i < g_
node_buf[ifidx].count; i++)
{
g_
node_buf[ifidx].
node_list[i].flag &= (~mask);
}
return;
}
/****************************************************************************
* Function : ip_address_pool_reserve
* Description: Ԥ����IP��ַ�أ���ͨ��IP��ͻ�����ЩIP��ַ�Ƿ����
*
Input :
node_buf�ڵ㻺��
* Output : N/A
* Return : �������ɵ�IP��ַ
****************************************************************************/
void ip_address_pool_reserve(
int ifidx,
NODE_BUF *
node_buf)
{
u_
int32 i = 0;
u_
int32 host = 0;
u_
int32 max_count = MAX_IP_ADDR_NUM;
u_
int32 gw_dec = 0;
NET_
NODE *local = NULL;
char gateway_str[STR_IP_LEN] = {0};
if (ifidx < 0 || MAX_NETIF_NUM <= ifidx || !
node_buf)
{
CHM_DPR
INTF(MSG_ERROR, "
invalid argument,
node = NULL\n");
return;
}
local = &
node_buf->local_
node;
if (OK != get_local_gateway(ifidx, gateway_str))
{
return;
}
IPv4_str
ing2IPv4_dec(gateway_str, &gw_dec);
/* ��������Ϊ32��ֱ�ӷ��� */
if ((~local->mask) == 0)
{
node_buf->count = 0;
CHM_DPR
INTF(MSG_ERROR, "mask is 32 bits %02x\n", local->mask);
return;
}
/* Ԥ����IP��ַ������С��255������IP��ַ���� */
if (max_count > (~local->mask - 1))
{
max_count = ~local->mask - 1;
}
node_buf->count = 0;
host = local->ip & local->mask;
for (i = 0; i < max_count; i++)
{
host++;
/* Ԥ����IP��ַ������NVR��ַ��ͬ */
if (host == local->ip)
{
cont
inue;
}
/* Ԥ����IP��ַ������������ͬ */
if (host == gw_dec)
{
cont
inue;
}
node_buf->
node_list[
node_buf->count].
node.ip = host;
node_buf->
node_list[
node_buf->count].
node.mask = local->mask;
node_buf->
node_list[
node_buf->count].flag = 0;
memset((void *)
node_buf->
node_list[
node_buf->count].
node.mac_hex, 0, MAC_HEX_LEN);
node_buf->count++;
}
return;
}
/*!
*\fn ipcnflct
info_add()
*\brief ip��ͻ��Ϣ��������mac.
*\details
*
*\param[
in]
node - �����ӽڵ��IP.
*\param[
in] newmac - ������MAC.
*\param[out] N/A.
*
*\return
int.
*\retval OK - �����ɹ�
*\ ERROR - ����ʧ��
*
*\note
*/
int ipcnflct
info_add(
int ifidx, u_
int32 ip, char *newmac)
{
int id = 0;
int ret = 0;
int notify = 0;
NET_
NODE_
INFO *
node = NULL;
IPCNFLCT
INFO_
NODE_T *p = NULL;
if (ifidx < 0 || MAX_NETIF_NUM <= ifidx)
{
return -1;
}
pthread_mutex_lock(&ipcnflct
info_lock);
id = f
ind_
node_buf_by_ip_addr(ifidx, ip);
if ((id >= 0) && (id < MAX_IP_ADDR_NUM))
{
node = g_
node_buf[ifidx].
node_list + id;
if (!
node)
{
ret = -1;
goto done;
}
}
else
{
ret = -1;
goto done;
}
/*!<��һ���ڵ�Ϊ
node->
node.mac_hex�����ⲻ������ͻҲ��̬���� */
if (memcmp(newmac,
node->
node.mac_hex, MAC_HEX_LEN) == 0)
{
ret = 0;
goto done;
}
p =
node->head;
/*!<�Ȳ����Ƿ��Ѵ��� */
while (p != NULL)
{
if (memcmp(newmac, p->mac_hex, MAC_HEX_LEN) == 0)
{
break;
}
p = p->next;
}
/*!<�����ڣ������� */
if (p == NULL)
{
/*!<�����ӣ������������Ϣ */
notify = 1;
node->hostno++;
/*!<�յ���һ��mac */
if (
node->hostno == 1)
{
node->flag |=
NODE_RCV_ARP_RSP;
memcpy(
node->
node.mac_hex, newmac, MAC_HEX_LEN);
}
/*!<������ͻ */
else if (
node->hostno >= 2)
{
p = (IPCNFLCT
INFO_
NODE_T *)chm_calloc(1, sizeof(IPCNFLCT
INFO_
NODE_T));
if (p == NULL)
{
CHM_DPR
INTF(MSG_ERROR, "Calloc failed.");
ret = -1;
goto done;
}
memcpy(p->mac_hex, newmac, MAC_HEX_LEN);
p->next =
node->head;
node->head = p;
node->flag |=
NODE_IP_
CONFLICT;
}
}
done:
pthread_mutex_unlock(&ipcnflct
info_lock);
if (notify)
{
if (
node)
{
CHM_DPR
INTF(MSG_DEBUG, "ip %#x
node->hostno %d, flag %d\r\n",
ip,
node->hostno,
node->flag);
}
else
{
CHM_DPR
INTF(MSG_WARN
ING, "NULL
node. ip %#x", ip);
}
}
return ret;
}
/*!
*\fn ipcnflct
info_tobedel_tag()
*\brief ip��ͻ��Ϣ��ɾ��host mac����Ϊ����IP��δ��ɣ��������յ�host arp�ظ����ּӻ���������
* ��stage������IP��ɺ����ύ.
*\details
*
*\param[
in] id - ����ǽڵ��ip.
*\param[
in] hostmac - ���������MAC.
*\param[out] N/A.
*
*\return
int.
*\retval OK - �����ɹ�
*\ ERROR - ����ʧ��
*
*\note
*/
int ipcnflct
info_del_staged(
int ifidx, u_
int32 ip, char *hostmac)
{
int id = 0;
int ret = 0;
NET_
NODE_
INFO *
node = NULL;
IPCNFLCT
INFO_
NODE_T *p = NULL;
if (ifidx < 0 || MAX_NETIF_NUM <= ifidx)
{
return -1;
}
pthread_mutex_lock(&ipcnflct
info_lock);
id = f
ind_
node_buf_by_ip_addr(ifidx, ip);
if ((id >= 0) && (id < MAX_IP_ADDR_NUM))
{
node = g_
node_buf[ifidx].
node_list + id;
if (!
node)
{
ret = -1;
goto done;
}
}
else
{
ret = -1;
goto done;
}
/*!<���ж��Ƿ�Ϊ��̬
node */
if (memcmp(hostmac,
node->
node.mac_hex, MAC_HEX_LEN) == 0)
{
/*!<����ǣ���ʣ��ڵ����0�����ƶ�λ�� */
node->hostno--;
if (
node->hostno > 0)
{
p =
node->head;
/*!<�ҵ�һ��δstage�Ķ�̬�ڵ� */
while (p != NULL)
{
if (p->del_staged == 0)
{
break;
}
p = p->next;
}
/*!<�������� */
if (p != NULL)
{
char tmpmac[MAC_HEX_LEN];
memcpy(tmpmac,
node->
node.mac_hex, MAC_HEX_LEN);
memcpy(
node->
node.mac_hex, p->mac_hex, MAC_HEX_LEN);
memcpy(p->mac_hex, tmpmac, MAC_HEX_LEN);
p->del_staged = 1;
}
else
{
/*!<this should not happed, as
node->hostno > 0 */
CHM_DPR
INTF(MSG_ERROR, "Fatal error: NULL
node. ip %#x.", ip);
node->
node_del_staged = 1;
}
}
else
{
node->
node_del_staged = 1;
}
}
/*!<���Ǿ�̬�ڵ㣬�ڶ�̬�ڵ��в��� */
else
{
p =
node->head;
while (p != NULL)
{
if (memcmp(hostmac, p->mac_hex, MAC_HEX_LEN) == 0)
{
break;
}
p = p->next;
}
/*!<���ڣ����� */
if (p != NULL)
{
p->del_staged = 1;
node->hostno--;
}
}
/*!<ֻ����FLAG������ɾ���ڵ㣬Ҳ�����ͷ��ڴ� */
/*!<ֻʣ���һ��IP */
if (
node->hostno == 1)
{
node->flag &= ~
NODE_IP_
CONFLICT;
}
/*!<���һ����ɾ���� */
else if (
node->hostno == 0)
{
node->flag &= ~
NODE_RCV_ARP_RSP;
}
done:
pthread_mutex_unlock(&ipcnflct
info_lock);
if (
node)
{
CHM_DPR
INTF(MSG_DEBUG, "ip %#x
node->hostno %d, flag %d\r\n",
ip,
node->hostno,
node->flag);
}
else
{
CHM_DPR
INTF(MSG_WARN
ING, "NULL
node. ip %#x\n", ip);
}
return ret;
}
/*!
*\fn ipcnflct
info_del_revert()
*\brief ����del stage������ʹ�ָ�ԭ״̬.
*\details
*
*\param[
in] N/A.
*\param[out] N/A.
*
*\return
int.
*\retval OK - �����ɹ�
*\ ERROR - ����ʧ��
*
*\note
*/
int ipcnflct
info_del_revert(
int ifidx)
{
int i = 0;
int need_refresh = 0;
NET_
NODE_
INFO *
node = NULL;
IPCNFLCT
INFO_
NODE_T *p = NULL;
if (ifidx < 0 || MAX_NETIF_NUM <= ifidx)
{
return -1;
}
pthread_mutex_lock(&ipcnflct
info_lock);
for (i = 0; i < g_
node_buf[ifidx].count; i++)
{
node = g_
node_buf[ifidx].
node_list + i;
/*!<����staged����Ϣ���ָ�hostno */
/*!<��һ���ڵ� */
if (
node->
node_del_staged)
{
node->
node_del_staged = 0;
node->hostno++;
need_refresh = 1;
}
/*!<��ͻ��Ϣ�ڵ� */
p =
node->head;
while (p != NULL)
{
if (p->del_staged)
{
p->del_staged = 0;
node->hostno++;
need_refresh = 1;
}
p = p->next;
}
/*!<����hostno������flag */
if (
node->hostno >= 1)
{
node->flag |=
NODE_RCV_ARP_RSP;
if (
node->hostno >= 2)
{
node->flag |=
NODE_IP_
CONFLICT;
}
}
}
if (need_refresh) g_
node_buf[ifidx].is_need_refreshall = 1;
pthread_mutex_unlock(&ipcnflct
info_lock);
CHM_DPR
INTF(MSG_DEBUG, "ipcnflct
info_del_revert\r\n");
return 0;
}
/*!
*\fn ipcnflct
info_free()
*\brief �ͷ�ip��ͻ��Ϣ.
*\details
*
*\param[
in]
node - IP�ڵ�.
*\param[out] N/A.
*
*\return
int.
*\retval OK - �����ɹ�
*\ ERROR - ����ʧ��
*
*\note
*/
int ipcnflct
info_free(NET_
NODE_
INFO *
node)
{
IPCNFLCT
INFO_
NODE_T *q = NULL;
IPCNFLCT
INFO_
NODE_T *p =
node->head;
pthread_mutex_lock(&ipcnflct
info_lock);
while (p != NULL)
{
q = p;
p = p->next;
chm_free(q);
}
node->head = NULL;
node->hostno = 0;
pthread_mutex_unlock(&ipcnflct
info_lock);
return 0;
}
/*!
*\fn ipcnflct
info_freeall()
*\brief �ͷ����е�ipcnflct
info�ڵ�.
*\details
*
*\param[
in] N/A.
*\param[out] N/A.
*
*\return
int.
*\retval OK - �����ɹ�
*\ ERROR - ����ʧ��
*
*\note
*/
int ipcnflct
info_freeall(void)
{
int i = 0;
int j = 0;
for (i = 0; i < MAX_NETIF_NUM; i++)
{
for (j = 0; j < g_
node_buf[i].count; j++)
{
ipcnflct
info_free(g_
node_buf[i].
node_list + j);
}
}
return 0;
}
/****************************************************************************
* Function : device_ip_addr_configure
* Description: ���ý���б��е��豸IP��ַ�����֧����MAX_DEVICE_NUM·
�豸IP��ַ
*
Input : list : �豸�б�
result : ��¼���ý����OK:�ɹ���ERROR:����
count : �����
* Output : N/A
* Return : �ɹ�����OK������ERROR
****************************************************************************/
CHM_STATUS device_ip_addr_configure(
int ifidx, NET_
NODE list[],
int32 result[], u_
int32 count)
{
int64 delta = 0;
int64
remain = 0;
u_
int32 ah_sip = 0;
int32 i = 0;
int32 ret = OK;
chm_bool f
inished = false;
NET_
NODE local;
RAW_SOCK raw_arp;
ARP_REQUEST request;
SET_IP_ADDR_PARAM param;
struct timeval tv;
struct timespec recv_bgn;
struct timespec recv_end;
ARP_HDR *ah = NULL;
if (ifidx < 0 || MAX_NETIF_NUM <= ifidx || !list || !result || count > MAX_DEVICE_NUM)
{
CHM_DPR
INTF(MSG_ERROR, "
invalid argument\n");
return CHM_STATUS_ARGS_
INVALID;
}
if (count == 0 || !strlen(g_netif_
info[ifidx].ifname))
{
return CHM_STATUS_OK;
}
raw_arp.sock = raw_socket_
init(ETH_P_ARP, g_netif_
info[ifidx].ifname);
if (raw_arp.sock < 0)
{
CHM_DPR
INTF(MSG_ERROR, "raw socket
init error\n");
return CHM_STATUS_ALLOC_ERROR;
}
get_local_ipaddr(g_netif_
info[ifidx].ifname, g_netif_
info[ifidx].ip);
get_
node_localhost(ifidx, &local);
get_local_gateway(ifidx, param.gateway_str);
IPv4_dec2IPv4_str
ing(local.mask, param.mask_str);
mac_hex2mac_str
ing(local.mac_hex, param.smac_str);
/* ����IPC IP��ַ */
for (i = 0; i < count; i++)
{
/* Ĭ������ʧ�� */
if (ifidx == list[i].ifidx)
{
result[i] = ERROR;
}
else
{
/*if not from this
interface, ignore*/
//result[i] = OK;
cont
inue;
}
if (strlen(list[i].password) == 0 && list[i].vender == VENDER_ID_HIKVISION
&& !strncmp(list[i].activate_status, "true", 4))
{
CHM_DPR
INTF(MSG_DEBUG, "hikvision set ip with no password. \n");
cont
inue;
}
IPv4_dec2IPv4_str
ing(list[i].ip, param.ip_str);
mac_hex2mac_str
ing(list[i].mac_hex, param.dmac_str);
param.vender = list[i].vender;
param.username = list[i].username;
param.password = list[i].password;
param.verify_data = list[i].veridy_data;
param.serial_number = list[i].serial_number;
param.encrypt_level = list[i].encrypt_level;
param.http_port = list[i].http_port;
param.ifidx = list[i].ifidx;
param.setip_with_pwd = list[i].setip_with_pwd;
CHM_DPR
INTF(MSG_DEBUG, "send set ip:%s, mac = %s\n", param.ip_str, param.dmac_str);
ret = send_set_ipaddr_frame(¶m);
if (ret != OK)
{
CHM_DPR
INTF(MSG_ERROR, "send set ip frame failed, mac = %s\n", param.dmac_str);
}
if (param.setip_with_pwd && ret == OK)
{
result[i] = param.error_code;
list[i].max_retry_count = param.max_retry_count;
list[i].
remain_retry_count = param.
remain_retry_count;
list[i].
remain_time = param.
remain_time;
}
}
/* ͨ��ARP��������Ƿ���� */
request.sip_dec = local.ip;
memcpy(request.smac_hex, local.mac_hex, MAC_HEX_LEN);
remain = sec2nanosec(IPADDR_SET_WAIT_TIMEOUT);
clock_gettime(CLOCK_MONOTONIC, &recv_bgn);
while (
remain > 0)
{
/* ���ü����ɱ�־ */
f
inished = TRUE;
for (i = 0; i < count; i++)
{
/*if set ip success or not from this
interface, don't send arp.*/
if (result[i] == OK || ifidx != list[i].ifidx)
{
cont
inue;
}
if (strlen(list[i].password) == 0 && list[i].vender == VENDER_ID_HIKVISION
&& !strncmp(list[i].activate_status, "true", 4))
{
CHM_DPR
INTF(MSG_DEBUG, "hikvision set ip with no password. don't send arp\n");
cont
inue;
}
if (list[i].setip_with_pwd)
{
cont
inue;
}
f
inished = FALSE;
request.tip_dec = list[i].ip;
ret = send_arp_request(&raw_arp, &request);
if (ret != OK)
{
CHM_DPR
INTF(MSG_ERROR, "send arp frame failed, ip = %x\n", request.tip_dec);
}
}
if (f
inished == TRUE)
{
break;
}
tv.tv_sec = 1;
tv.tv_usec = 0;
/* ����ARP���ģ�����Ƿ��г�ͻ���� */
while (1)
{
ret = recv_arp_packet(&raw_arp, &tv);
if (ret != OK)
{
break;
}
/* ��ʱ����δ�յ�ARP���� */
if (raw_arp.len == 0)
{
break;
}
ah = (ARP_HDR *)(raw_arp.rcv_buffer + sizeof(ETH_HEADER));
if (ntohs(ah->ar_op) == ARPOP_REPLY || ntohs(ah->ar_op) == ARPOP_REQUEST)
{
memcpy(&ah_sip, ah->ar_sip, IPv4_DEC_LEN);
ah_sip = ntohl(ah_sip);
}
else
{
cont
inue;
}
for (i = 0; i < count; i++)
{
if (list[i].setip_with_pwd)
{
cont
inue;
}
if (list[i].ip == ah_sip && !memcmp(list[i].mac_hex, ah->ar_sha, MAC_HEX_LEN))
{
result[i] = OK;
break;
}
}
}
clock_gettime(CLOCK_MONOTONIC, &recv_end);
delta = sec2nanosec(recv_end.tv_sec) + recv_end.tv_nsec
- (sec2nanosec(recv_bgn.tv_sec) + recv_bgn.tv_nsec);
recv_bgn.tv_sec = recv_end.tv_sec;
recv_bgn.tv_nsec = recv_end.tv_nsec;
remain -= delta;
}
close(raw_arp.sock);
return CHM_STATUS_OK;
}
/****************************************************************************
* Function : arp_request_send_timer
* Description: 1��IP��ͻ��ⶨʱ����������ARP Request���ͣ�target IPΪNVR IP
��
node_buff IP��ַ��IP��
2����һ�߳��н���ARP RSP���IJ�����
*
Input : param : �������
* Output : N/A
* Return : N/A
****************************************************************************/
void *arp_request_send_timerfunc(void *param)
{
int32 ret = CHM_STATUS_ERROR;
int32 i = 0;
chm_bool enabled = FALSE;
RTSP_CONN_STATUS conn_status = RTSP_CONN_S_UNKNOWN;
RAW_SOCK *temp = NULL;
RAW_SOCK raw_arp;
ARP_REQUEST request;
NET_
NODE local;
/*
node_buf IP�������Ϊ600s����ʱ����ʱ600/12�Σ��ŷ���ARP���� */
static u_
int32 timer_counts = 0;
pthread_mutex_lock(&timer_lock);
temp = (RAW_SOCK *)param;
if (NULL == temp)
{
CHM_DPR
INTF(MSG_ERROR, "
invalid argument\n");
goto done;
}
if (temp->sock == -1)
{
CHM_DPR
INTF(MSG_ERROR, "
invalid argument\n");
goto done;
}
raw_arp.sock = temp->sock;
raw_arp.ifidx = temp->ifidx;
timer_counts++;
if (temp->sock_reopen)
{
timer_counts = 0;
temp->sock_reopen = 0;
}
memset((void *)&local, 0, sizeof(local));
ret = get_
node_localhost(raw_arp.ifidx, &local);
if (ret != CHM_STATUS_OK)
{
CHM_DPR
INTF(MSG_DEBUG, "get_
node_localhost failed\n");
if (CHM_STATUS_ARGS_
INVALID == ret)
{
goto done;
}
/* �������IP��ͻ�澯�����澯ȡ�� */
if (g_
node_buf[raw_arp.ifidx].cur_
conflict == IP_
CONFLICT_STATUS_TRUE)
{
g_
node_buf[raw_arp.ifidx].cur_
conflict = IP_
CONFLICT_STATUS_FALSE;
record_ip_
conflict_report(IP_
CONFLICT_STATUS_FALSE);
}
goto done;
}
/* NVR IP��ַ�����������Ҫ���¸��µ�ַ�� */
if ((g_
node_buf[raw_arp.ifidx].local_
node.ip != local.ip)
|| (g_
node_buf[raw_arp.ifidx].local_
node.mask != local.mask)
|| g_
node_buf[raw_arp.ifidx].is_need_refreshall)
{
g_
node_buf[raw_arp.ifidx].is_need_refreshall = 0;
memcpy(&g_
node_buf[raw_arp.ifidx].local_
node, &local, sizeof(local));
g_
node_buf[raw_arp.ifidx].cur_
conflict = IP_
CONFLICT_STATUS_FALSE;
ipcnflct
info_freeall();
g_
node_buf[raw_arp.ifidx].count = 0;
memset((void *)&g_
node_buf[raw_arp.ifidx].
node_list, 0, sizeof(g_
node_buf[raw_arp.ifidx].
node_list));
ip_address_pool_reserve(raw_arp.ifidx, &g_
node_buf[raw_arp.ifidx]);
timer_counts = 0;
}
/* NVR IP��ͻ״̬��������澯 */
if (g_
node_buf[raw_arp.ifidx].pre_
conflict != g_
node_buf[raw_arp.ifidx].cur_
conflict)
{
record_ip_
conflict_report(g_
node_buf[raw_arp.ifidx].cur_
conflict);
}
g_
node_buf[raw_arp.ifidx].pre_
conflict = g_
node_buf[raw_arp.ifidx].cur_
conflict;
g_
node_buf[raw_arp.ifidx].cur_
conflict = IP_
CONFLICT_STATUS_FALSE;
/* ����NVR����ARP̽������ */
request.sip_dec = 0;
request.tip_dec = local.ip;
memcpy(request.smac_hex, local.mac_hex, MAC_HEX_LEN);
ret = send_arp_request(&raw_arp, &request);
if (ret != OK)
{
CHM_DPR
INTF(MSG_NOTICE, "send arp request failed\n");
}
/* ����
node_buf IP��ַ��IP ARP̽������ */
if (0 == timer_counts % (RESELVE_IP_DETECT_PERIOD / IP_
CONFLICT_DETECT_PERIOD))
{
request.sip_dec = local.ip;
memcpy(request.smac_hex, local.mac_hex, MAC_HEX_LEN);
for (i = 0; i < g_
node_buf[raw_arp.ifidx].count; i++)
{
g_
node_buf[raw_arp.ifidx].
node_list[i].flag = 0;
ipcnflct
info_free(g_
node_buf[raw_arp.ifidx].
node_list + i);
memset((void *)&g_
node_buf[raw_arp.ifidx].
node_list[i].
node.mac_hex, 0, MAC_HEX_LEN);
request.tip_dec = g_
node_buf[raw_arp.ifidx].
node_list[i].
node.ip;
ret = send_arp_request(&raw_arp, &request);
if (ret != OK)
{
CHM_DPR
INTF(MSG_ERROR, "send arp request failed, tip is %x\n", request.tip_dec);
}
}
}
/* ���NVR IP��ַ�����������Ҫ֪ͨRTSPֹͣ���� */
if ( (g_
node_buf[raw_arp.ifidx].local_
node.ip != 0)
&& (g_
node_buf[raw_arp.ifidx].local_
node.ip != local.ip || g_
node_buf[raw_arp.ifidx].local_
node.mask != local.mask) )
{
for (i = 0; i < MAX_CHANNEL_NUM; i++)
{
get_channel_enable(i, &enabled);
get_channel_connect_status(i, &conn_status);
if (enabled == TRUE && conn_status == RTSP_CONN_S_SUCCESS)
{
channel_rtsp_connect(i, CHANNEL_RTSP_M_STOP);
}
}
}
done:
pthread_mutex_unlock(&timer_lock);
if (0 == local
node_freshed)
{
pthread_mutex_lock(&ipcnflct
info_lock);
local
node_freshed = 1;
pthread_cond_signal(&ipcnflct
info_cond);
pthread_mutex_unlock(&ipcnflct
info_lock);
}
return OK;
}
/****************************************************************************
* Function : arp_request_send_timer
* Description: ��ʼ��NVR IP��ַ��ͻ��ⶨʱ������ʱ���Ͳ�ѯ����IP��ַ��
ARP����
*
Input :
* Output : N/A
* Return : �ɹ�����OK����������ERROR
****************************************************************************/
void *arp_request_send_timer(void *param)
{
if (!param)
{
CHM_DPR
INTF(MSG_ERROR, "
invalid ptr param:%p\n", param);
return NULL;
}
arp_request_send_timerfunc(param);
recv_center_add(RECV_CENTER_TIMER_FD, param, NULL, NULL, IP_
CONFLICT_DETECT_PERIOD, arp_request_send_timer, RECV_CENTER_PRIO_UBUS);
return NULL;
}
/****************************************************************************
* Function : arp_request_send_timer_
init
* Description: ��ʼ��NVR IP��ַ��ͻ��ⶨʱ������ʱ���Ͳ�ѯ����IP��ַ��
ARP����
*
Input : timer : ��ʱ���ṹ
param : ��ʱ������
* Output : N/A
* Return : �ɹ�����OK����������ERROR
****************************************************************************/
CHM_STATUS arp_request_send_timer_
init(void *param)
{
if (!param)
{
CHM_DPR
INTF(MSG_ERROR, "
invalid ptr param:%p\n", param);
return CHM_STATUS_ARGS_
INVALID;
}
/* ����IP��ͻ��ⶨʱ�� */
recv_center_add(RECV_CENTER_TIMER_FD, param, NULL, NULL, 0, arp_request_send_timer, RECV_CENTER_PRIO_UBUS);
return CHM_STATUS_OK;
}
/****************************************************************************
* Function : ip_
conflict_detect_thread
* Description: IP��ͻ����̣߳���ͻ������������:
(1) �������:��ʱ��ͨ��ARPЭ��������Ƿ����IP��ͻ
(2) �������:ʼ�ս��վ������ڵ�ARP�������ж��Ƿ����IP��ͻ
*
Input : N/A
* Output : N/A
* Return : ��������±��̲߳��˳�
****************************************************************************/
void *ip_
conflict_detect_thread(void *param)
{
NETIF_
INFO *
info = NULL;
RAW_SOCK *raw_arp;
struct timeval tv;
u_
int32 ah_sip = 0;
u_
int32 ah_tip = 0;
u_
int32 ah_op = 0;
ARP_HDR *ah = NULL;
char rcv_buffer[RAW_PACKET_LEN_MAX];
int32 ret = CHM_STATUS_OK;
int
index = 0;
pthread_detach(pthread_self());
set_thread_name("ip
ConflictDet");
if (!param)
{
return NULL;
}
index = *((
int*)param);
chm_free(param);
info = &g_netif_
info[
index];
raw_arp = &g_raw_arp[
index];
if (!strlen(
info->ifname))
{
goto exit;
}
raw_arp->ifidx = get_netif_
index(
info);
if (-1 == raw_arp->ifidx)
{
goto exit;
}
raw_arp->sock = raw_socket_
init(ETH_P_ARP,
info->ifname);
if (raw_arp->sock < 0)
{
CHM_DPR
INTF(MSG_ERROR, "raw socket
init error\n");
goto exit;
}
/* ��ʼ��IP��ͻ��ⶨʱ�� */
arp_request_send_timer_
init((void *)raw_arp);
while (1)
{
/* IP��ͻ��� */
tv.tv_sec = ARP_RECV_TIMEOUT_SEC;
tv.tv_usec = ARP_RECV_TIMEOUT_USEC;
/* ����ARP���ģ�����Ƿ��г�ͻ���� */
if (raw_arp->sock < 0)
{
raw_arp->sock = raw_socket_
init(ETH_P_ARP,
info->ifname);
if (raw_arp->sock < 0)
{
cont
inue;
}
}
ret = recv_arp_packet(raw_arp, &tv);
if (ret != OK)
{
cont
inue;
}
/* ��ʱ����δ�յ�ARP���� */
if (raw_arp->len == 0)
{
cont
inue;
}
memcpy(rcv_buffer, raw_arp->rcv_buffer, sizeof(rcv_buffer));
ah = (ARP_HDR *)(rcv_buffer + sizeof(ETH_HEADER));
/* ��������������ΪREPLY��REQUEST��ARP���� */
ah_op = ntohs(ah->ar_op);
if (ah_op != ARPOP_REPLY
&& ah_op != ARPOP_REQUEST)
{
cont
inue;
}
memcpy(&ah_sip, ah->ar_sip, IPv4_DEC_LEN);
ah_sip = ntohl(ah_sip);
memcpy(&ah_tip, ah->ar_tip, IPv4_DEC_LEN);
ah_tip = ntohl(ah_tip);
/* ������豸�б��Ƿ���ڳ�ͻ */
if (ah_sip == g_
node_buf[raw_arp->ifidx].local_
node.ip)
{
if (memcmp(g_
node_buf[raw_arp->ifidx].local_
node.mac_hex, ah->ar_sha, MAC_HEX_LEN))
{
g_
node_buf[raw_arp->ifidx].cur_
conflict = IP_
CONFLICT_STATUS_TRUE;
}
cont
inue;
}
/* Special case: IPv4 duplicate address detection packet (RFC2131) */
else if(0 == ah_sip
&& ARPOP_REQUEST == ah_op
&& ah_tip == g_
node_buf[raw_arp->ifidx].local_
node.ip
&& memcmp(g_
node_buf[raw_arp->ifidx].local_
node.mac_hex, ah->ar_sha, MAC_HEX_LEN))
{
g_
node_buf[raw_arp->ifidx].cur_
conflict = IP_
CONFLICT_STATUS_TRUE;
cont
inue;
}
/* ����
node IP��ַ�б�����ʾ�Ƿ��ͻ */
ipcnflct
info_add(raw_arp->ifidx, ah_sip, (char*)ah->ar_sha);
}
close(raw_arp->sock);
exit:
pthread_exit(NULL);
return NULL;
}
/****************************************************************************
* Function : local
node_change_handler
* Description: IP��ͻ����̣߳���ͻ������������:
(1) �������:��ʱ��ͨ��ARPЭ��������Ƿ����IP��ͻ
(2) �������:ʼ�ս��վ������ڵ�ARP�������ж��Ƿ����IP��ͻ
*
Input : N/A
* Output : N/A
* Return : ��������±��̲߳��˳�
****************************************************************************/
int local
node_change_handler(void)
{
int i = 0;
for (i = 0; i < MAX_NETIF_NUM; i++)
{
if (!strlen(g_netif_
info[i].ifname))
{
cont
inue;
}
g_raw_arp[i].ifidx = get_netif_
index(&g_netif_
info[i]);
if (-1 == g_raw_arp[i].ifidx)
{
cont
inue;
}
if (g_raw_arp[i].sock)
{
close(g_raw_arp[i].sock);
}
g_raw_arp[i].sock = raw_socket_
init(ETH_P_ARP, g_netif_
info[i].ifname);
g_raw_arp[i].ifidx = i;
g_raw_arp[i].sock_reopen = 1;
local
node_freshed = 0;
/*!<��recv center����ִ��arp request func */
if (recv_center_add(RECV_CENTER_TIMER_FD, (void*)&g_raw_arp[i], NULL, NULL, 1, arp_request_send_timerfunc, RECV_CENTER_PRIO_UBUS))
{
CHM_DPR
INTF(MSG_ERROR, "Add func to recv center failed.\n");
}
}
return OK;
}
/****************************************************************************
* Function : chm_ipaddr_manager_data_
init
* Description: ��ʼ���������Լ�ȫ�ֱ���ֵ
*
Input : N/A
* Output : N/A
* Return : �ɹ�����OK������ERROR
****************************************************************************/
static CHM_STATUS chm_ipaddr_manager_data_
init()
{
int i = 0;
memset(g_
node_buf, 0, sizeof(g_
node_buf));
for (i = 0; i < MAX_NETIF_NUM; i++)
{
if (!strlen(g_netif_
info[i].ifname))
{
cont
inue;
}
ip_address_pool_reserve(i, &g_
node_buf[i]);
}
return CHM_STATUS_OK;
}
/****************************************************************************
* Function : chm_ipaddr_manager_
init
* Description: IP��ַ��ͻ���ģ���ʼ��
*
Input : N/A
* Output : N/A
* Return : �ɹ�����OK,��������ERROR
****************************************************************************/
CHM_STATUS chm_ipaddr_manager_
init()
{
pthread_t tid = -1;
int32 ret = CHM_STATUS_OK;
int i = 0;
/* ��ȡ�����豸���� */
load_network_config();
ret = chm_ipaddr_manager_data_
init();
if (ret != CHM_STATUS_OK)
{
CHM_DPR
INTF(MSG_FATAL, "chm ipaddr manager data lock
init error\n");
return CHM_STATUS_ERROR;
}
for (i = 0; i < MAX_NETIF_NUM; i++)
{
memset(&g_raw_arp[i], 0, sizeof(RAW_SOCK));
}
for (i = 0; i < MAX_NETIF_NUM; i++)
{
int *p = (
int *)chm_calloc(1, sizeof(
int));
*p = i;
ret = pthread_create(&tid, NULL, ip_
conflict_detect_thread, (void *)p);
if (ret)
{
CHM_DPR
INTF(MSG_FATAL, "create thread \"ip_
conflict_detect_thread\" failed\n");
return CHM_STATUS_ERROR;
}
}
return CHM_STATUS_OK;
}
int check_ip_
conflict(u_
int32 *ip_list,
int *result,
int num)
{
int ifidx;
RAW_SOCK raw_arp[MAX_NETIF_NUM] = {0};
ARP_REQUEST request;
NET_
NODE local;
int ret;
int i;
struct timeval tv;
ARP_HDR *ah = NULL;
u_
int32 ah_sip = 0;
int recv_num;
struct timespec recv_bgn;
struct timespec recv_end;
int64 time_use = 0;
if (!ip_list || !result)
{
return CHM_STATUS_ERROR;
}
for (ifidx = 0; ifidx < MAX_NETIF_NUM; ifidx++)
{
raw_arp[ifidx].sock = raw_socket_
init(ETH_P_ARP, g_netif_
info[ifidx].ifname);
if (raw_arp[ifidx].sock < 0)
{
CHM_DPR
INTF(MSG_ERROR, "ifidx:%d raw socket
init error\n", ifidx);
cont
inue;
}
raw_arp[ifidx].ifidx = ifidx;
memset((void *)&local, 0, sizeof(local));
ret = get_
node_localhost(raw_arp[ifidx].ifidx, &local);
if (ret != CHM_STATUS_OK)
{
CHM_DPR
INTF(MSG_DEBUG, "get_
node_localhost failed\n");
cont
inue;
}
request.sip_dec = local.ip;
memcpy(request.smac_hex, local.mac_hex, MAC_HEX_LEN);
for (i = 0; i < num; i++)
{
request.tip_dec = ip_list[i];
ret = send_arp_request(&raw_arp[ifidx], &request);
if (ret != OK)
{
CHM_DPR
INTF(MSG_ERROR, "send arp request failed, tip is %x\n", request.tip_dec);
}
}
}
for (ifidx = 0; ifidx < MAX_NETIF_NUM; ifidx++)
{
if (raw_arp[ifidx].sock < 0)
{
cont
inue;
}
recv_num = 0;
clock_gettime(CLOCK_MONOTONIC, &recv_bgn);
while(1)
{
tv.tv_sec = 0;
tv.tv_usec = IP_CHECK_TIMEOUT;
ret = recv_arp_packet(&raw_arp[ifidx], &tv);
if (ret != OK)
{
CHM_DPR
INTF(MSG_ERROR, "ifidx:%d recv err\n", ifidx);
break;
}
/* ��ʱ����δ�յ�ARP���� */
if (raw_arp[ifidx].len == 0)
{
CHM_DPR
INTF(MSG_ERROR, "ifidx:%d recv none\n", ifidx);
break;
}
ah = (ARP_HDR *)(raw_arp[ifidx].rcv_buffer + sizeof(ETH_HEADER));
if (ntohs(ah->ar_op) == ARPOP_REPLY)
{
memcpy(&ah_sip, ah->ar_sip, IPv4_DEC_LEN);
ah_sip = ntohl(ah_sip);
}
else
{
cont
inue;
}
for (i = 0; i < num; i++)
{
if (ip_list[i] == ah_sip)
{
result[i] = UBUS_ECODE_IP_
CONFLICT;
CHM_DPR
INTF(MSG_ERROR, "ifidx:%d i:%d target recv\n", ifidx, i);
recv_num++;
break;
}
}
if (recv_num == num)
{
CHM_DPR
INTF(MSG_ERROR, "recv_num == num break\n");
break;
}
clock_gettime(CLOCK_MONOTONIC, &recv_end);
time_use = sec2nanosec(recv_end.tv_sec) + recv_end.tv_nsec - (sec2nanosec(recv_bgn.tv_sec) + recv_bgn.tv_nsec);
if (time_use > IP_CHECK_TIMEOUT*2)
{
CHM_DPR
INTF(MSG_ERROR, "timeout break\n");
break;
}
}
close(raw_arp[ifidx].sock);
}
return CHM_STATUS_OK;
}
在使用 SVN 更新项目时遇到文件 te02.pdf 显示为红色，提示 skipped 和 noderemaininconflict。常规的 IDEA SVN revert 功能无法解决。通过运行特定命令成功解决了冲突问题，参考了相关技术文章找到了解决方案。
扫一扫
2138
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
