dhcp

Linux renew ip command

$ sudo dhclient -r //release ip 释放IP

$ sudo dhclient //获取IP

DHCP server 10.0.9.1 发现 Client发过来的 DHCP Request 他本身处理不了，所以他马上发了一个NAK让他不要再发了。

然后Client端发了一个广播（discover），希望得到新的IP。Server端用Offer包返回。
然后Client端发了一个广播（Request），Server端用ACK包返回。分配IP成功。
Client端用获取的IP向组内广播(Inform), 意思是别人就不要用这个IP了。

另外，DHCP server能不能发NAK , 取决于 server 的配置文件dhcp.conf中是否有authoritative。如果没有， server端就不会发NAK, client端会反复发3个（Linux）或者7个（Windows）的Request, 之后才能发DIiscover重新获取IP，非常慢。如果Client部署在Windows上的，常需要等一分钟左右。

配置DHCP服务器

1、建立光盘挂载位置 mkdir -p /media/cdrom

2、挂载光盘设备文件 mount /dev/cdrom /media/cdrom

3、进入到SERVER模式下 cd /media/cdrom/Server

4、查看DHCP文件 ls dhcp*

5、cp文件到/etc/dhcpd.conf cp /user/share/doc/dhcp-3.0.5/dhcpd.conf.sample /etc/dhcpd.conf

6、编辑dhcpd.conf vi /etc/dhcpd.conf

7、重启dhcp server dhcpd restart

配置DHCP客户端

1、设置网卡eth0通过DHCP获取IP地址

vi /etc/sysconfig/network-soripts/ifcfg-eth0

2、重启网卡服务 ifdown eth0;idup eth0

3、使用dhclient-d eth0 获取地址 dhclient -d eth0

默认的/etc/dhcpd.conf含义如下：
ddns-update-style interim; //设置dhcp互动更新模式
ignore client-updates; //忽略客户端更新
subnet 192.168.12.0 netmask 255.255.255.0 {
//设置子网申明
# --- default gateway
option routers 192.168.12.1; //设置客户端默认网关
option subnet-mask 255.255.255.0; //设置客户端子网掩码
option nis-domain "ixdba.net "; //设置NIS域
option domain-name " ixdba.net "; //设置DNS域
option domain-name-servers 192.168.12.1; //设置DNS服务器地址
option time-offset -18000; # Eastern Standard Time //设置时间偏差
# option ntp-servers 192.168.12.1;
# option netbios-name-servers 192.168.12.1;
# --- Selects point-to-point node (default is hybrid). Don't change this unless
# -- you understand Netbios very well
# option netbios-node-type 2;
range dynamic-bootp 192.168.12.128 192.168.12.254; //设置地址池
default-lease-time 21600; //设置默认租期，单位为秒
max-lease-time 43200; //设置客户端最长租期，单位为秒
# we want the nameserver to appear at a fixed address
host ns { //以下设定分配静态IP地址，不多做解释。
next-server marvin.RedHat.com;
hardware ethernet 12:34:56:78:AB:CD;
fixed-address 207.175.42.254;
}
}

其他说明：

range 192.168.12.2 192.168.12.125; 可以限定分配的IP地址范围。

如果想给某IP分配固定的IP地址，修改host 那一项，把网卡的Mac地址和IP进行绑定，就是最后那一段，改为相应的就可以了。

在subnet里定义的网段要与你的网卡IP所处网段一致，也就是说比如你的网卡是192.168.0.x，而dhcp服务却为10.1.1.0的subnet提供服务是不行的，是启动不了的

1、申请ip
dhclient eth0
2、释放ip
dhclient eth0 -r

3、windows命令行相应命令
ipconfig /renew
ipconfig /release

#! /bin/sh

OUTGOING=`ping -c1 192.168.1.1 |grep 192.168.1.1 |grep -c ttl`

if [ $OUTGOING -eq 0 ]

then

dhclient eth1

fi

root [ /home ]# which dhclient

/sbin/dhclient

然后把dhclient改成完全路径

改成这样，比如

/sbin/dhclient eth1

dhclient eth0 >/tmp/dhc.log 2>&1

这个 2>&1 是什么意思呢？

错误日志跟正常日志都打印到一个文件中

获得IP等：dhclient eth0

释放IP： dhclient -r eth0

NAME

dhclient是一个DHCP协议客户端，它使用DHCP协议或者BOOTP协议或在这两个协议都不可用时使用静态地址来配置一个或多个网络接口

SYNOPSIS

dhclient [ -4 | -6 ] [ -S ] [ -N [ -N... ] ] [ -T [ -T... ] ] [ -P [ -P... ] ] [ -p port ] [ -d ] [ -e VAR=value ] [ -q ] [ -1 ] [ -r | -x ] [ -lf lease-

file ] [ -pf pid-file ] [ --no-pid ] [ -cf config-file ] [ -sf script-file ] [ -s server-addr ] [ -g relay ] [ -n ] [ -nw ] [ -w ] [ -v ] [ --version ] [ if0

[ ...ifN ]

dhclient.conf

EXAMPLES

The following configuration file is used on a laptopwhich has an IP alias of192.5.5.213,and has one interface,ep0(a 3Com 3C589C).Booting intervals have been shortened somewhat from the default, becausethe client is known to spend most of its time on networks
with little DHCPactivity.The laptop does roam to multiple networks.

timeout 60;
retry 60;
reboot 10;
select-timeout 5;
initial-interval 2;
reject 192.33.137.209;

interface "ep0" {
send host-name "andare.fugue.com";
send dhcp-client-identifier 1:0:a0:24:ab:fb:9c;
send dhcp-lease-time 3600;
supersede domain-name "fugue.com rc.vix.com home.vix.com";
prepend domain-name-servers 127.0.0.1;
request subnet-mask, broadcast-address, time-offset, routers,
domain-name, domain-name-servers, host-name;
require subnet-mask, domain-name-servers;
script "/etc/dhclient-script";
media "media 10baseT/UTP", "media 10base2/BNC";
}

alias {
interface "ep0";
fixed-address 192.5.5.213;
option subnet-mask 255.255.255.255;
}

cp /sbin/udhcpc /server

udpsvd -vE 0.0.0.0 69 tftpd /server
tftp -r udhcpc -g 1.1.1.253

udhcpd -f /app/cfg/udhcpd.conf &

/udhcpc eth0
修改ip地址
root@CRong:cfg$ cat netcfg
#!/bin/sh
NET_ETH0=1.1.1.252/0
NET_GW=1.1.1.144/0
NET_PORT=800
root@CRong:cfg# cat netconfig
config ip wan
option addr 192.168.1.253
option mask 255.255.255.0
config ip gw
option addr 192.168.1.1
option mask 255.255.255.0
config ip lan
option addr 1.1.1.253
option mask 255.255.255.0
option mode static

a8busybox dhcp配置

root@user:busybox-1.20.2# cat .config|grep DHCPC
CONFIG_UDHCPC6=y
CONFIG_UDHCPC=y
CONFIG_FEATURE_UDHCPC_ARPING=y
CONFIG_UDHCPC_DEFAULT_SCRIPT="/usr/share/udhcpc/default.script"
CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS=80
CONFIG_IFUPDOWN_UDHCPC_CMD_OPTIONS="-R -n"

318busybox dhcp配置

[root@localhost busybox-1.13.4]# cat .config|grep DHCPC
# CONFIG_APP_UDHCPC is not set
# CONFIG_FEATURE_UDHCPC_ARPING is not set
CONFIG_UDHCPC_DEFAULT_SCRIPT=""
CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS=

嵌入式linux内核和根文件系统可以存放在各种可能的存储设备中，一般情况下我们将内核和根文件系统直接烧入到Flash中(包括NOR和NAND flash)，这种方法的缺点是在内核和根文件系统出现修改时我们就不得不得重新对flash进行擦除和烧写工作

(3) Cramfs：Compressed ROM File System

　　Cramfs是Linux的创始人 Linus Torvalds参与开发的一种只读的压缩文件系统。它也基于MTD驱动程序。在cramfs文件系统中，每一页(4KB)被单独压缩，可以随机页访问，其压缩比高达2:1,为嵌入式系统节省大量的Flash存储空间，使系统可通过更低容量的FLASH存储相同的文件，从而降低系统成本。

　　Cramfs文件系统以压缩方式存储，在运行时解压缩，所以不支持应用程序以XIP方式运行，所有的应用程序要求被拷到RAM里去运行，但这

并不代表比 Ramfs需求的RAM空间要大一点，因为Cramfs是采用分页压缩的方式存放档案，在读取档案时，不会一下子就耗用过多的内存空间，

只针对目前实际读取的部分分配内存，尚没有读取的部分不分配内存空间，当我们读取的档案不在内存时，Cramfs文件系统自动计算压缩后的

资料所存的位置，再即时解压缩到 RAM中。另外，它的速度快，效率高，其只读的特点有利于保护文件系统免受破坏，提高了系统的可靠性。
由于以上特性，Cramfs在嵌入式系统中应用广泛。但是它的只读属性同时又是它的一大缺陷，使得用户无法对其内容对进扩充

Linux启动时，第一个必须挂载的是根文件系统；若系统不能从指定设备上挂载根文件系统，则系统会出错而退出启动。成功之后可以自动

或手动挂载其他的文件系统根文件系统首先是一种文件系统，该文件系统不仅具有普通文件系统的 存储数据文件的功能，但是相对于普通的文件系统，它的特殊之处在于，它是内核启动时所mount的第一个文件系统，内核代码的映像文件保存在根文件系统 中，系统引导启动程序会在根文件系统挂载之后从中把一些初始化脚本（如rcS,inittab）和服务加载到内存中去运行。我们要明白文件系统和内核是完
全独立的两个部分。在嵌入式中移植的内核下载到开发板上，是没有办法真正的启动Linux操作系统的，会出现无法加载文件系统的错误。

那么根文件系统在系统启动中到底是什么时候挂载的呢？先将/dev/ram0挂载，而后执行/linuxrc.等其执行完后。切换根目录，再挂载具体的根 文件系统.根文件系统执行完之后，也就是到了Start_kernel()函数的最后，执行init的进程，也就第一个用户进程

nand read 0x30007FC0 0x100000 0x200000;bootm 0x30007FC0意思就是，先去读取nand flash，从0x100000开始，长度为0x200000的数据到memory的0x30007FC0处，然后bootm表示从memory的0x30007FC0开始运行。也就是去运行你的内核镜像了。此处也就是你的ramdisk.image.gz。而你的地址是0x10140000，所以，上面中的启动命令，至少0x100000要改成你的地址0x10140000。然后，内核会自己解压缩，然后执行,初始化硬件，加载驱动模块，最后去挂载rootfs，而此文件系统是什么格式的，是从uboot里面定义的：#define
CONFIG_BOOTARGS "root=/dev/mtdblock2 rw init=/linuxrc console=ttyS0,115200 mem=16M rootfstype=yafffs2"

上面中root=/dev/mtdblock2，表示，要去/dev/mtdblock2,也就是你的mtd的第3个分区，去加载。而这里的mtd的第3个分区具体对应的nand flash中的的地址，是你在内核中，一般是在core.c自己定义的的nand flash的分区。一般是uboot是第一个分区，内核kernel是第二个，然后就是rootfs是第三个分区，也就是/dev/mtdblock2。

static struct mtd_partition rm9200_partitions[3] ={ { /* uboot 256K */ .name = "uboot", .size = 0x40000, .offset = 0 }, { /* kernel 1.768M */ .name = "kernel",
.size = 0x1C0000, .offset = 0x40000 }, { /* rootfs 2M */ .name = "rootfs", .size = 0x200000, .offset = 0x200000 },};

static struct mtd_partition c300evm_nor_parts[] = {static struct mtd_partition c300evm_nand_parts[] = {

static struct mtd_partition c300evm_nand_parts[] = { { .name = "csp", .size = 2 * SZ_1M, .offset = 0, }, { .name = "msp", .size = 4*SZ_1M, .offset = MTDPART_OFS_APPEND, }, {
.name = "spare", .size = 218*SZ_1M, .offset = MTDPART_OFS_APPEND, }, { .name = "fs", .size = 32*SZ_1M, .offset = MTDPART_OFS_APPEND, },};struct resource c300evm_nand_resources[] = { {
.start = COMCERTO_NAND_BASE, .end = COMCERTO_NAND_BASE + 0x200 - 1, .flags = IORESOURCE_MEM, },};

获取gw ip 地址

#define BUFSIZE 8192

struct route_info
{
u_int dstAddr;
u_int srcAddr;
u_int gateWay;
char ifName[IF_NAMESIZE];
};

int readNlSock(int sockFd, char *bufPtr, int seqNum, int pId)
{
struct nlmsghdr *nlHdr;
int readLen = 0, msgLen = 0;
do{
//收到内核的应答
if((readLen = recv(sockFd, bufPtr, BUFSIZE - msgLen, 0)) < 0)
{
perror("SOCK READ: ");
return -1;
}
nlHdr = (struct nlmsghdr *)bufPtr;
//检查header是否有效
if((NLMSG_OK(nlHdr, readLen) == 0) || (nlHdr->nlmsg_type == NLMSG_ERROR))
{
perror("Error in recieved packet");
return -1;
}
if(nlHdr->nlmsg_type == NLMSG_DONE)
{
break;
}
else
{
bufPtr += readLen;
msgLen += readLen;
}
if((nlHdr->nlmsg_flags & NLM_F_MULTI) == 0)
{
break;
}
} while((nlHdr->nlmsg_seq != seqNum) || (nlHdr->nlmsg_pid != pId));
return msgLen;
}

//分析返回的路由信息
void parseRoutes(struct nlmsghdr *nlHdr, struct route_info *rtInfo,char *gateway, char *ifName)
{
struct rtmsg *rtMsg;
struct rtattr *rtAttr;
int rtLen;
char *tempBuf = NULL;
struct in_addr dst;
struct in_addr gate;

tempBuf = (char *)malloc(100);
rtMsg = (struct rtmsg *)NLMSG_DATA(nlHdr);
// If the route is not for AF_INET or does not belong to main routing table
//then return.
if((rtMsg->rtm_family != AF_INET) || (rtMsg->rtm_table != RT_TABLE_MAIN))
return;

rtAttr = (struct rtattr *)RTM_RTA(rtMsg);
rtLen = RTM_PAYLOAD(nlHdr);
for(;RTA_OK(rtAttr,rtLen);rtAttr = RTA_NEXT(rtAttr,rtLen)){
switch(rtAttr->rta_type) {
case RTA_OIF:
if_indextoname(*(int *)RTA_DATA(rtAttr), rtInfo->ifName);
break;
case RTA_GATEWAY:
rtInfo->gateWay = *(u_int *)RTA_DATA(rtAttr);
break;
case RTA_PREFSRC:
rtInfo->srcAddr = *(u_int *)RTA_DATA(rtAttr);
break;
case RTA_DST:
rtInfo->dstAddr = *(u_int *)RTA_DATA(rtAttr);
break;
}
}
dst.s_addr = rtInfo->dstAddr;
if (strstr((char *)inet_ntoa(dst), "0.0.0.0"))
{
sprintf(ifName, "%s", rtInfo->ifName);
//printf("oif:%s",rtInfo->ifName);
gate.s_addr = rtInfo->gateWay;
sprintf(gateway, "%s", (char *)inet_ntoa(gate));
//printf("%s\n",gateway);
gate.s_addr = rtInfo->srcAddr;
//printf("src:%s\n",(char *)inet_ntoa(gate));
gate.s_addr = rtInfo->dstAddr;
//printf("dst:%s\n",(char *)inet_ntoa(gate));
}
free(tempBuf);
return;
}

int get_gateway(char *gateway, char *ifName)
{
struct nlmsghdr *nlMsg;
struct rtmsg *rtMsg;
struct route_info *rtInfo;
char msgBuf[BUFSIZE];

int sock, len, msgSeq = 0;

if((sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE)) < 0)
{
perror("Socket Creation: ");
return -1;
}
memset(msgBuf, 0, BUFSIZE);

nlMsg = (struct nlmsghdr *)msgBuf;
rtMsg = (struct rtmsg *)NLMSG_DATA(nlMsg);

nlMsg->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)); // Length of message.
nlMsg->nlmsg_type = RTM_GETROUTE; // Get the routes from kernel routing table .

nlMsg->nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST; // The message is a request for dump.
nlMsg->nlmsg_seq = msgSeq++; // Sequence of the message packet.
nlMsg->nlmsg_pid = getpid(); // PID of process sending the request.

if(send(sock, nlMsg, nlMsg->nlmsg_len, 0) < 0){
printf("Write To Socket Failed…\n");
return -1;
}

if((len = readNlSock(sock, msgBuf, msgSeq, getpid())) < 0) {
printf("Read From Socket Failed…\n");
return -1;
}
rtInfo = (struct route_info *)malloc(sizeof(struct route_info));
for(;NLMSG_OK(nlMsg,len);nlMsg = NLMSG_NEXT(nlMsg,len)){
memset(rtInfo, 0, sizeof(struct route_info));
parseRoutes(nlMsg, rtInfo, gateway, ifName);
}
free(rtInfo);
close(sock);
return 0;
}

// int main()
// {
// char buff[256], ifName[12];
// get_gateway(buff, ifName);
// printf("interface:%s\ngetway: %s\n",ifName, buff);
// return 0;
// }