iproute2.diff

一个可以实现MPLS实验的linux源代码.你不仅可以实现单层标签的转发,还可以实现2个标签的实验,很好的.

+	struct genlmsghdr		*ghdr;
+	struct {
+		struct nlmsghdr		n;
+		char			buf[4096];
+	} req;
+	struct mpls_in_label_req	mil;
+	struct mpls_instr_req		instr;
+
+	memset(&req, 0, sizeof(req));
+	memset(&mil, 0, sizeof(mil));
+	memset(&instr, 0, sizeof(instr));
+
+	req.n.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
+	req.n.nlmsg_flags = NLM_F_REQUEST|flags;
+	req.n.nlmsg_type = PF_MPLS;
+
+	ghdr = NLMSG_DATA(&req.n);
+	ghdr->cmd = cmd;
+
+	mil.mil_proto = AF_INET;
+
+	while (argc > 0) {
+		if (strcmp(*argv, "labelspace") == 0) {
+			__u32 ls;
+			NEXT_ARG();
+			if (get_unsigned(&ls, *argv, 0) || ls > 255)
+				invarg(*argv, "invalid labelspace");
+			mil.mil_label.ml_index = ls;
+		} else if (strcmp(*argv, "label") == 0) {
+			NEXT_ARG();
+			mpls_parse_label(&mil.mil_label, &argc, &argv);
+		} else if (strcmp(*argv, "proto") == 0) {
+			NEXT_ARG();
+			if (strncmp(*argv, "ipv4", 4) == 0) {
+				mil.mil_proto = AF_INET;
+			} else if (strncmp(*argv, "ipv6", 4) == 0) {
+				mil.mil_proto = AF_INET6;
+			} else if (strncmp(*argv, "packet", 6) == 0) {
+				mil.mil_proto = AF_PACKET;
+			} else {
+				invarg(*argv, "invalid ilm proto");
+			}
+			mil.mil_change_flag |= MPLS_CHANGE_PROTO;
+		} else if (strcmp(*argv, "instructions") == 0) {
+			NEXT_ARG();
+			mpls_parse_instr(&instr, &argc, &argv, MPLS_IN);
+			mil.mil_change_flag |= MPLS_CHANGE_INSTR;
+		} else {
+			invarg(*argv, "invalid ilm argument");
+		}
+		argc--; argv++;
+	}
+
+	if (!mil.mil_label.ml_type) {
+		fprintf(stderr, "you must specify a label value\n");
+		exit(1);
+	}
+
+	addattr_l(&req.n, sizeof(req), MPLS_ATTR_ILM, &mil, sizeof(mil));
+	addattr_l(&req.n, sizeof(req), MPLS_ATTR_INSTR, &instr, sizeof(instr));
+
+	if (rtnl_talk(&rth2, &req.n, 0, 0, NULL, NULL, NULL) < 0)
+		exit(2);
+
+	return 0;
+}
+
+int
+mpls_nhlfe_modify(int cmd, unsigned flags, int argc, char **argv)
+{
+	struct genlmsghdr		*ghdr;
+	struct {
+		struct nlmsghdr		n;
+		char			buf[4096];
+	} req;
+	struct mpls_out_label_req 	mol;
+	struct mpls_instr_req 		instr;
+
+	memset(&req, 0, sizeof(req));
+	memset(&mol, 0, sizeof(mol));
+	memset(&instr, 0, sizeof(instr));
+
+	req.n.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
+	req.n.nlmsg_flags = NLM_F_REQUEST|flags;
+	req.n.nlmsg_type = PF_MPLS;
+
+	ghdr = NLMSG_DATA(&req.n);
+	ghdr->cmd = cmd;
+
+	while (argc > 0) {
+		if (strcmp(*argv, "key") == 0) {
+			__u32 key;
+			NEXT_ARG();
+			if (get_unsigned(&key, *argv, 0))
+				invarg(*argv, "invalid key");
+			mol.mol_label.u.ml_key = key;
+			mol.mol_label.ml_type = MPLS_LABEL_KEY;
+		} else if (strcmp(*argv, "mtu") == 0) {
+			__u32 mtu;
+			NEXT_ARG();
+			if (get_unsigned(&mtu, *argv, 0))
+				invarg(*argv, "invalid mtu");
+			mol.mol_mtu = mtu;
+			mol.mol_change_flag |= MPLS_CHANGE_MTU;
+		} else if (strcmp(*argv, "no_propagate_ttl") == 0) {
+			mol.mol_propagate_ttl = 0;
+			mol.mol_change_flag |= MPLS_CHANGE_PROP_TTL;
+		} else if (strcmp(*argv, "propagate_ttl") == 0) {
+			mol.mol_propagate_ttl = 1;
+			mol.mol_change_flag |= MPLS_CHANGE_PROP_TTL;
+		} else if (strcmp(*argv, "instructions") == 0) {
+			NEXT_ARG();
+			mpls_parse_instr(&instr, &argc, &argv, MPLS_OUT);
+			mol.mol_change_flag |= MPLS_CHANGE_INSTR;
+		} else {
+			usage();
+		}
+		argc--; argv++;
+	}
+
+	addattr_l(&req.n, sizeof(req), MPLS_ATTR_NHLFE, &mol, sizeof(mol));
+	addattr_l(&req.n, sizeof(req), MPLS_ATTR_INSTR, &instr, sizeof(instr));
+
+	if (flags & NLM_F_CREATE) {
+		if (rtnl_talk(&rth1, &req.n, 0, 0, &req.n, NULL, NULL) < 0)
+			exit(2);
+
+		print_mpls(NULL, &req.n, stdout);
+	} else {
+		if (rtnl_talk(&rth2, &req.n, 0, 0, NULL, NULL, NULL) < 0)
+			exit(2);
+	}
+
+	return 0;
+}
+
+int
+mpls_xc_modify(int cmd, unsigned flags, int argc, char **argv)
+{
+	struct genlmsghdr		*ghdr;
+	struct {
+		struct nlmsghdr 	n;
+		char			buf[4096];
+	} req;
+	struct mpls_xconnect_req	xc;
+
+	memset(&req, 0, sizeof(req));
+	memset(&xc, 0, sizeof(xc));
+
+	req.n.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
+	req.n.nlmsg_flags = NLM_F_REQUEST|flags;
+	req.n.nlmsg_type = PF_MPLS;
+
+	ghdr = NLMSG_DATA(&req.n);
+	ghdr->cmd = cmd;
+
+	while (argc > 0) {
+
+		if (strcmp(*argv, "ilm_labelspace") == 0) {
+			__u32 ls;
+			NEXT_ARG();
+			if (get_unsigned(&ls, *argv, 0) || ls > 255)
+				invarg(*argv, "invalid labelspace");
+			xc.mx_in.ml_index = ls;
+		} else if (strcmp(*argv, "ilm_label") == 0) {
+			NEXT_ARG();
+			mpls_parse_label(&xc.mx_in, &argc, &argv);
+		} else if (strcmp(*argv, "nhlfe_key") == 0) {
+			__u32 key;
+			NEXT_ARG();
+			if (get_unsigned(&key, *argv, 0))
+				invarg(*argv, "invalid key");
+			xc.mx_out.u.ml_key = key;
+			xc.mx_out.ml_type = MPLS_LABEL_KEY;
+		} else {
+			usage();
+		}
+		argc--; argv++;
+	}
+
+	if (!xc.mx_in.ml_type) {
+		fprintf(stderr, "you must specify a ILM label value\n");
+		exit(1);
+	}
+
+	if (!xc.mx_out.u.ml_key) {
+		fprintf(stderr, "you must specify a NHLFE key\n");
+		exit(1);
+	}
+
+	addattr_l(&req.n, sizeof(req), MPLS_ATTR_XC, &xc, sizeof(xc));
+
+	if (rtnl_talk(&rth2, &req.n, 0, 0, NULL, NULL, NULL) < 0)
+		exit(2);
+
+	return 0;
+}
+
+int
+mpls_labelspace_modify(int cmd, unsigned flags, int argc, char **argv)
+{
+	__u32 labelspace = -2;
+	struct genlmsghdr		*ghdr;
+	struct {
+		struct nlmsghdr 	n;
+		char			buf[4096];
+	} req;
+	struct mpls_labelspace_req 	ls;
+
+	memset(&req, 0, sizeof(req));
+	memset(&ls, 0, sizeof(ls));
+
+	req.n.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
+	req.n.nlmsg_flags = NLM_F_REQUEST|flags;
+	req.n.nlmsg_type = PF_MPLS;
+
+	ghdr = NLMSG_DATA(&req.n);
+	ghdr->cmd = cmd;
+
+	while (argc > 0) {
+		if (strcmp(*argv, "dev") == 0) {
+			NEXT_ARG();
+			ls.mls_ifindex = ll_name_to_index(*argv);
+		} else if (strcmp(*argv, "labelspace") == 0) {
+			NEXT_ARG();
+			if (get_unsigned(&labelspace, *argv, 0))
+				invarg(*argv, "invalid labelspace");
+			ls.mls_labelspace = labelspace;
+		} else {
+			usage();
+		}
+		argc--; argv++;
+	}
+
+	if (ls.mls_ifindex == 0 || ls.mls_labelspace == -2) {
+		fprintf(stderr, "Invalid arguments\n");
+		exit(1);
+	}
+
+	addattr_l(&req.n, sizeof(req), MPLS_ATTR_LABELSPACE, &ls, sizeof(ls));
+
+	if (rtnl_talk(&rth2, &req.n, 0, 0, NULL, NULL, NULL) < 0)
+		exit(2);
+
+	return 0;
+}
+
+int
+mpls_tunnel_modify(int cmd, int argc, char **argv)
+{
+	unsigned int key = -2;
+	struct ifreq ifr;
+	int err;
+	int fd;
+
+	memset(&ifr, 0, sizeof(ifr));
+
+	while (argc > 0) {
+		if (strcmp(*argv, "dev") == 0) {
+			NEXT_ARG();
+			strncpy(ifr.ifr_name, *argv, IFNAMSIZ);
+		} else if (strcmp(*argv, "nhlfe") == 0) {
+			NEXT_ARG();
+			if (get_unsigned(&key, *argv, 0))
+				invarg(*argv, "invalid NHLFE key");
+			ifr.ifr_ifru.ifru_ivalue = key;
+		} else {
+			usage();
+		}
+		argc--; argv++;
+	}
+
+	if (!strlen(ifr.ifr_name)) {
+		fprintf(stderr, "You must specify a interface name\n");
+		exit(1);
+	}
+
+	fd = socket(AF_INET, SOCK_DGRAM, 0);
+	err = ioctl(fd, cmd, &ifr);
+	if (err)
+		perror("ioctl");
+
+	return 0;
+}
+
+void print_mpls_stats(FILE *fp, struct gnet_stats_basic *st)
+{
+	fprintf(fp, " (%llu bytes, %u pkts)",
+		(unsigned long long)st->bytes, st->packets);
+}
+
+void print_address(FILE *fp, struct sockaddr *addr) {
+	char buf[256];
+	switch (addr->sa_family) {
+		case AF_INET:
+		{
+			struct sockaddr_in *sin = (struct sockaddr_in*)addr;
+			inet_ntop(addr->sa_family, &sin->sin_addr,
+				buf, sizeof(buf));
+			fprintf(fp, "ipv4 %s ", buf);
+			break;
+		}
+		case AF_INET6:
+		{
+			struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)addr;
+			inet_ntop(addr->sa_family, &sin6->sin6_addr,
+				buf, sizeof(buf));
+			fprintf(fp, "ipv6 %s ", buf);
+			break;
+		}
+		case AF_PACKET:
+		{
+			fprintf(fp, "packet");
+			break;
+		}
+		default:
+			fprintf(fp, "<unknown address family %d> ",
+				addr->sa_family);
+	}
+}
+
+void print_label(FILE *fp, struct mpls_label *label) {
+	switch (label->ml_type) {
+		case MPLS_LABEL_GEN:
+			fprintf(fp, "gen %d ", label->u.ml_gen);
+			break;
+		case MPLS_LABEL_ATM:
+			fprintf(fp, "atm %d/%d ", label->u.ml_atm.mla_vpi,
+				label->u.ml_atm.mla_vci);
+			break;
+		case MPLS_LABEL_FR:
+			fprintf(fp, "fr %d ", label->u.ml_fr);
+			break;
+		case MPLS_LABEL_KEY:
+			fprintf(fp, "key 0x%08x ", label->u.ml_key);
+			break;
+		default:
+			fprintf(fp, "<unknown label type %d> ", label->ml_type);
+	}
+}
+
+void print_instructions(FILE *fp, struct mpls_instr_req *instr) 
+{
+	struct mpls_instr_elem *ci;   /* current instruction */
+	unsigned int key;
+	int i,j;
+
+	for(i = 0;i < instr->mir_instr_length;i++) {
+		ci = &instr->mir_instr[i];
+
+		switch (ci->mir_opcode) {
+			case MPLS_OP_NOP:
+				fprintf(fp, "noop ");
+				break;
+			case MPLS_OP_POP:
+				fprintf(fp, "pop ");
+				break;
+			case MPLS_OP_PEEK:
+				fprintf(fp, "peek ");
+				break;
+			case MPLS_OP_PUSH:
+				fprintf(fp, "push ");
+				print_label(fp, &ci->mir_push);
+				break;
+			case MPLS_OP_FWD:
+				fprintf(fp, "forward ");
+				print_label(fp, &ci->mir_fwd);
+				break;
+			case MPLS_OP_DLV:
+				fprintf(fp, "deliver ");
+				break;
+			case MPLS_OP_SET:
+				fprintf(fp, "set %s ",
+					ll_index_to_name(ci->mir_set.mni_if));
+				print_address(fp, &ci->mir_set.mni_addr);
+				break;				
+			case MPLS_OP_SET_RX:
+				fprintf(fp, "set-rx-if %s ",
+					ll_index_to_name(ci->mir_set_rx));
+				break;
+			case MPLS_OP_SET_TC:
+				fprintf(fp, "set-tcindex %hu ",ci->mir_set_tc);
+				break;
+			case MPLS_OP_SET_DS:
+				fprintf(fp, "set-dscp %hu ",ci->mir_set_ds);
+				break;
+			case MPLS_OP_SET_EXP:
+				fprintf(fp, "set-exp %hhu ",ci->mir_set_exp);
+				break;	
+			case MPLS_OP_NF_FWD:
+				fprintf(fp, "nffwd 0x%2.2hhx ",
+					ci->mir_nf_fwd.nf_mask);
+
+				for(j=0;j<MPLS_NFMARK_NUM;j++) {
+					key = ci->mir_nf_fwd.nf_key[j];
+					if (key) fprintf(fp,"%d %8.8x ",j,key);
+				}
+				break;
+			case MPLS_OP_DS_FWD:
+				fprintf(fp, "dsfwd 0x%2.2hhx ",
+					ci->mir_ds_fwd.df_mask);
+
+				for(j=0;j<MPLS_DSMARK_NUM;j++) {
+					key = ci->mir_ds_fwd.df_key[j];
+					if (key) fprintf(fp,"%d %8.8x ",j,key);
+				}
+				break;
+			case MPLS_OP_EXP_FWD:
+				fprintf(fp, "exp-fwd ");
+
+				for(j=0;j<MPLS_EXP_NUM;j++) {
+					key = ci->mir_exp_fwd.ef_key[j];
+					if (key) fprintf(fp,"%d %8.8x ",j,key);
+				}
+				break;
+			case MPLS_OP_EXP2TC:
+				fprintf(fp, "exp2tc ");
+
+				for(j=0;j<MPLS_EXP_NUM;j++) {
+					fprintf(fp,"%d %hu ",
+						j,ci->mir_exp2tc.e2t[j]);
+
+				}
+				break;
+			case MPLS_OP_EXP2DS:
+				fprintf(fp, "exp2ds ");
+
+				for(j=0;j<MPLS_EXP_NUM;j++) {
+					fprintf(fp,"%d %hhu ",
+						j,ci->mir_exp2ds.e2d[j]);
+				}
+				break;
+			case MPLS_OP_TC2EXP:
+				fprintf(fp, "tc2exp 0x%2.2hhx ",
+					ci->mir_tc2exp.t2e_mask);
+
+				for(j=0;j<MPLS_TCINDEX_NUM;j++) {
+					fprintf(fp,"%d %hhu ",
+						j,ci->mir_tc2exp.t2e[j]);
+
+				}
+				break;
+			case MPLS_OP_DS2EXP:
+				fprintf(fp, "ds2exp 0x%2.2hhx ",
+					ci->mir_ds2exp.d2e_mask);
+
+				for(j=0;j<MPLS_DSMARK_NUM;j++) {
+					fprintf(fp,"%d %hhu ",
+						j,ci->mir_ds2exp.d2e[j]);
+
+				}
+				break;
+			case MPLS_OP_NF2EXP:
+				fprintf(fp, "nf2exp 0x%2.2hhx ",
+					ci->mir_nf2exp.n2e_mask);
+
+				for(j=0;j<MPLS_NFMARK_NUM;j++) {
+					fprintf(fp,"%d %hhu ",
+						j,ci->mir_nf2exp.n2e[j]);
+
+				}
+				break;	
+			default:
+				fprintf(fp, "<unknown opcode %d> ", 
+					ci->mir_opcode);
+		}
+	}
+}
+
+int print_ilm(const struct nlmsghdr *n, void *arg, struct rtattr **tb)
+{
+	FILE *fp = (FILE*)arg;
+	struct mpls_in_label_req *mil;
+	struct mpls_instr_req *instr;
+	struct gnet_stats_basic *stats;
+        struct genlmsghdr *ghdr = NLMSG_DATA(n);
+
+	if ((ghdr->cmd != MPLS_CMD_NEWILM &&
+	    ghdr->cmd != MPLS_CMD_DELILM) ||
+	    (!tb[MPLS_ATTR_ILM])) {
+		fprintf(stderr, "Not an ILM\n");