精华内容
下载资源
问答
  • 1功能概述该系统是一个基于局域网广播系统,使用了多点广播这种相当新的技术,可以将信息发送给那些等待接收信息的接收者,有服务器端和客户端两部分,由服务器端进行广播,服务器端循环播放选定的文件,每隔几...

    1功能概述

    该系统是一个基于局域网的广播系统,使用了多点广播这种相当新的技术,可以将信息发送给那些等待接收信息的接收者,有服务器端和客户端两部分,由服务器端进行广播,服务器端循环播放选定的文件,每隔几秒钟播放一条消息,为用户学习及资源共享提供网络上的便利。客户端只需运行相应的客户端程序,就可以接收到服务器广播的信息,客户端可以随时开始或停止接收广播。同时,局域网内的任意节点均可将本地时间与服务器端时间同步。这种小型系统轻巧实用,可移植性好,在网络学习上利用的非常广泛。

    3.2.2功能划分

    (1)文件选择、广播时间及接收时间控制:

    服务器端可选择要广播的文件,控制广播的开始和结束,客户端可控制解手广播的开始和结束。

    (2)广播内容显示:

    服务器可显示已广播的内容、正在广播的内容、客户端则可显示已接收的内容和正在接收的内容。

    (3)数据发送:

    服务器端可读取所广播文件的内容,将其打包并发送出去,同样,还必须获取本地系统时间和日期,打包再发送。

    (4)数据接收:

    客户端可接收数据报,将数据还原并显示在文本框中。

    (5)时间同步:

    客户端将获取的表示时间日期的数据报作为参数,以此来设置本地时间和日期。

    3.3模块划分及功能分析

    设计系统的功能模块如下:

    服务器端:

    (1) 选择文件、开始及停止广播模块

    ① 选择所要播放的文件

    ② 开始广播

    ③ 停止广播

    (2) 文本显示模块

    ① 显示正在播放的内容

    ② 显示已经播放的内容

    (3) 本地时间日期处理模块

    ① 获取当前服务器时间日期

    ② 将时间日期格式化

    ③ 给格式化后的时间日期加标志

    (4) 广播套接字及广播范围模块

    ① 确定组播地址及端口号

    ② 设定数据报的生存期

    ③ 将套接字加入到同一组中

    (5) 数据打包发送模块

    ① 数据打包并发送

    客户端:

    (1) 接收时间控制模块

    ① 开始接收数据

    ② 停止接收数据

    (2) 接收内容显示模块

    ① 显示正在接收的内容

    ② 显示已经接收的内容

    (3) 包的接收及处理模块

    ① 获取数据包

    ② 将数据包中的数据还原

    ③ 根据标志将时间日期包和普通包分离

    (4) 时间同步

    ① 去除时间日期标志

    ② 设置本地时间日期

    模块的具体功能如下:

    (1) 选择文件、开始及停止广播模块

    ① 选择文件

    主要功能:在本地计算机上选择一个要广播的文件

    ② 开始及停止广播

    主要功能:激发一个事件,服务器端开始广播或停止广播数据

    (2) 文本显示模块

    ① 正在接收内容显示区

    主要功能:显示当前正在接收的内容,时间日期信息除外

    ② 已经接收内容显示区

    主要功能:将目前为止已接收的所有信息显示出来,时间日期信息除外

    (3) 本地时间日期处理模块

    ① 时间获取

    主要功能:调用系统函数,将当前的时间日期存放到一个类对象中

    ② 时间日期的格式化

    主要功能:分别给时间和日期规定一种格式 ,如日期格式为"yyyy-MM-dd",时间的格式为"HH:mm:ss",并将类对象中的数据按这种格式格式化

    ③ 区分格式化后的日期和时间字符串

    主要功能:将格式化后的数据加上标志,如时间字符串前加"t",日期字符串前加"d"

    (4) 组播设置模块

    主要功能: 用一个D类地址建立一个组播组,创建一个固定端口上的多点广播套接字,并将套接字加入到组中,做好广播数据报的前期工作;设置数据报的生存期——局域网范围内。

    (5) 数据打包和发送模块

    主要功能:将字符串中的数据存放到字节数组中,然后创建在指定地址,指定端口上广播的数据报,然后再利用多点广播套接字将数据包发送出去。

    (6) 接收时间控制模块

    主要功能:任意控制客户端接收时间。

    ① 开始接收数据。启动线程,开始接收数据报。

    ② 停止接收数据。中断线程,不再接收数据。

    (7) 接收内容显示模块

    主要功能:显示已接收和正在接收的内容。

    ① 正在接收。将前一条内容清空,显示当前接收的非时间日期数据。

    ② 已经接收。将当前接收的非时间日期数据加入到文本中。

    (8) 数据报的接收及处理模块

    主要功能:创建多点广播套接字,从组播组中接收数据报,并将数据报还原为字符串,判断字符串的起始标志,筛选出表示时间的字符串、表示日期的字符串以及其他普通的串,如以"t"开头的串表示时间,以"d"开头的串表示日期。

    (9) 时间同步模块

    主要功能:将收到的时间日期包中的数据设置为本地系统时间。

    ① 去除时间日期标志模块

    主要功能:将表示时间和日期的字符串去除标志,如将表示时间的串中的标志"t"去除,将新的串存放至字符串中;同样,将表示日期的串中的标志"d"去除,将新串放至字符串中备用。将MS-DOS下命令"cmd /c time "或"cmd /c date "作为字符串和前面分离出来的子串合并。

    ② 设置本地时间日期模块

    主要功能:利用系统函数调用MS-DOS下设置系统时间,日期的命令改变当前系统的时间日期。

    以上是大纲或介绍,如需要完整的资料或者如不符合您的要求,请联系技术人员qq:58850198咨询

    展开全文
  • [Android]获取局域网广播地址的两种方法 第一种是自己写的,有一些bug,不过凑合着用也可以,第二种是stackoverflow的,推荐用这种。 (1) private InetAddress calcBroadcastAddress(InetAddress mask, ...

    [Android]获取局域网广播地址的两种方法

    第一种是自己写的,有一些bug,不过凑合着用也可以,第二种是stackoverflow的,推荐用这种。

    (1)

    private InetAddress calcBroadcastAddress(InetAddress mask, InetAddress ip)
    			throws IOException {
    		int ipaddress = getIntAddress(ip);
    		int maskaddress = getIntAddress(mask);
    		int broadcast = ipaddress & maskaddress | ~maskaddress;
    		byte[] quads = new byte[4];
    		for (int k = 0; k < 4; k++) {
    			quads[k] = (byte) ((broadcast >> k * 8) & 0xFF);
    		}
    		return InetAddress.getByAddress(quads);
    	}
    
    	private InetAddress getBroadcastAddress() throws IOException {
    		// 自动获取
    		String strIp = getCommandResult("/system/bin/getprop",
    				"dhcp.eth0.ipaddress");
    		String strMask = getCommandResult("/system/bin/getprop",
    				"dhcp.eth0.mask");
    		if (!strIp.equals("\n")) {
    			InetAddress mask = InetAddress.getByName(strMask);
    			InetAddress ip = InetAddress.getByName(strIp);
    			Log.v("ws-discovery", "auto ip:" + strIp);
    			return calcBroadcastAddress(mask, ip);
    
    		} else {
    			// 手动配置
    			String strManual = getCommandResult("/system/bin/ifconfig", "eth0");
    			String[] netInfo = strManual.split(" ");
    			if (netInfo.length >= 5) {
    				InetAddress mask = InetAddress.getByName(netInfo[4]);
    				InetAddress ip = InetAddress.getByName(netInfo[2]);
    				Log.v("ws-discovery", "manual ip:" + netInfo[2]);
    				return calcBroadcastAddress(mask, ip);
    			}
    		}
    		// wifi
    		WifiManager wifi = (WifiManager) mContext
    				.getSystemService(Context.WIFI_SERVICE);
    		DhcpInfo dhcp = wifi.getDhcpInfo();
    		Log.v("ws-discovery", "wifi ip:" + Integer.toString(dhcp.ipAddress));
    		int broadcast = (dhcp.ipAddress & dhcp.netmask) | ~dhcp.netmask;
    		byte[] quads = new byte[4];
    		for (int k = 0; k < 4; k++) {
    			quads[k] = (byte) ((broadcast >> k * 8) & 0xFF);
    		}
    		return InetAddress.getByAddress(quads);
    	}
    private int getIntAddress(InetAddress address) {
    		byte[] addrs = address.getAddress();
    		int addr = 0;
    		addr = ((addrs[3] & 0xff) << 24) | ((addrs[2] & 0xff) << 16)
    				| ((addrs[1] & 0xff) << 8) | (addrs[0] & 0xff);
    		return addr;
    	}
    
    	private String getCommandResult(String commands, String args) {
    		Process process = null;
    		String inet = null;
    		try {
    			process = new ProcessBuilder().command(commands, args)
    					.redirectErrorStream(true).start();
    			InputStream in = process.getInputStream();
    			int count = 0;
    			while (count == 0) {
    				count = in.available();
    			}
    			byte[] b = new byte[count];
    			in.read(b);
    			inet = new String(b);
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			if (process != null)
    				process.destroy();
    		}
    		return inet;
    	}
    
    


    (2)

    public static String getBroadcast() throws SocketException {
    	    System.setProperty("java.net.preferIPv4Stack", "true");
    	    for (Enumeration<NetworkInterface> niEnum = NetworkInterface.getNetworkInterfaces(); niEnum.hasMoreElements();) {
    	        NetworkInterface ni = niEnum.nextElement();
    	        if (!ni.isLoopback()) {
    	            for (InterfaceAddress interfaceAddress : ni.getInterfaceAddresses()) {
    	            	if (interfaceAddress.getBroadcast() != null) {
    	            		return interfaceAddress.getBroadcast().toString().substring(1);
    					}
    	            }
    	        }
    	    }
    	    return null;
    	}
    展开全文
  • //FileName:IpClassify.java package xiaoqiang.main; /**  * @author nKF65624  *  */ public class IpClassify {  private String ip; ... public IpClassify(String ip, String i

    //FileName:IpClassify.java

    package xiaoqiang.main;

    /**
     * @author nKF65624
     *
     */
    public class IpClassify {
     private String ip;
     private String ipmask;

     public IpClassify(String ip, String ipmask) {
      this.ip = ip;
      this.ipmask = ipmask;
     }

     public String[] getNetAndBoradAddr() {
      // 设定A类子网位数最小为8
      // 设定B类子网位数最小为16
      // 设定C类子网位数最小为24
      int netmaskcount = getNetBoradMask();
      if (getSubNetKind() == 1) {
       if (netmaskcount < 8) {
        System.err.println("无效网络,A类网子网掩码需大于等于8位");
        return(new String[]{"0.0.0.0","255.255.255.255"});
       }else {
        return(new String[]{getANetworkNumber(netmaskcount)[0],getANetworkNumber(netmaskcount)[1]});
       }
      } else if (getSubNetKind() == 2) {
       if (netmaskcount < 16) {
        System.err.println("无效网络,C类网子网掩码需大于等于16位");
        return(new String[]{"0.0.0.0","255.255.255.255"});
       }else {
        return(new String[]{getANetworkNumber(netmaskcount)[0],getANetworkNumber(netmaskcount)[1]});
       }
      } else if (getSubNetKind() == 3) {
       if (netmaskcount < 24) {
        System.err.println("无效网络,C类网子网掩码需大于等于24位");
        return(new String[]{"0.0.0.0","255.255.255.255"});
       } else {
        return(new String[]{getANetworkNumber(netmaskcount)[0],getANetworkNumber(netmaskcount)[1]});
       }
      }
      else {
       return(new String[]{"0.0.0.0","255.255.255.255"});
      }
     }
     public String[] getANetworkNumber(int netmaskcount) {
      char[]  mybit= { '0', '0', '0', '0', '0', '0', '0', '0' };
      int[] inIpArray = getStrBlock(ip);
      if(netmaskcount>=24)
      {
       for (int i = 0; i < (netmaskcount - 24); i++) {
        mybit[i] = '1';
       }
       String mystr="";
       for(int i=0;i<mybit.length;i++)
       {
        mystr=mystr+mybit[i];
       }
       String returnStrnetwork=inIpArray[0]+"."+inIpArray[1]+"."+inIpArray[2];
       String returnStrBoardAddr="";
       int mytemp=256-Integer.parseInt(mystr, 2);
       int temp=inIpArray[3]/mytemp;
       returnStrBoardAddr=returnStrnetwork+"."+String.valueOf(mytemp*(temp+1)-1);
       returnStrnetwork=returnStrnetwork+"."+(temp)*mytemp;
       return new String[]{returnStrnetwork,returnStrBoardAddr};
      }
      else if(netmaskcount>=16)
      {
       for (int i = 0; i < (netmaskcount - 16); i++) {
        mybit[i] = '1';
       }
       String mystr="";
       for(int i=0;i<mybit.length;i++)
       {
        mystr=mystr+mybit[i];
       }
       String returnStrnetwork=inIpArray[0]+"."+inIpArray[1];
       String returnStrBoardAddr="";
       int mytemp=256-Integer.parseInt(mystr, 2);
       int temp=inIpArray[2]/mytemp;
       returnStrBoardAddr=returnStrnetwork+"."+String.valueOf(mytemp*(temp+1)-1)+".255";
       returnStrnetwork=returnStrnetwork+"."+(temp)*mytemp+".0";
       return new String[]{returnStrnetwork,returnStrBoardAddr};
      }
      else
      {
       for (int i = 0; i < (netmaskcount - 8); i++) {
        mybit[i] = '1';
       }
       String mystr="";
       for(int i=0;i<mybit.length;i++)
       {
        mystr=mystr+mybit[i];
       }
       String returnStrnetwork=String.valueOf(inIpArray[0]);
       String returnStrBoardAddr="";
       int mytemp=256-Integer.parseInt(mystr, 2);
       int temp=inIpArray[2]/mytemp;
       returnStrBoardAddr=returnStrnetwork+"."+String.valueOf(mytemp*(temp+1)-1)+".255.255";
       returnStrnetwork=returnStrnetwork+"."+(temp)*mytemp+".0.0";
       return new String[]{returnStrnetwork,returnStrBoardAddr};
      }
     }

     public String[] getBNetworkNumber(int netmaskcount) {
      char[]  mybit= { '0', '0', '0', '0', '0', '0', '0', '0' };
      int[] inIpArray = getStrBlock(ip);
      if(netmaskcount>=24)
      {
       for (int i = 0; i < (netmaskcount - 24); i++) {
        mybit[i] = '1';
       }
       String mystr="";
       for(int i=0;i<mybit.length;i++)
       {
        mystr=mystr+mybit[i];
       }
       String returnStrnetwork=inIpArray[0]+"."+inIpArray[1]+"."+inIpArray[2];
       String returnStrBoardAddr="";
       int mytemp=256-Integer.parseInt(mystr, 2);
       int temp=inIpArray[3]/mytemp;
       returnStrBoardAddr=returnStrnetwork+"."+String.valueOf(mytemp*(temp+1)-1);
       returnStrnetwork=returnStrnetwork+"."+(temp)*mytemp;
       return new String[]{returnStrnetwork,returnStrBoardAddr};
      }
      else
      {
       for (int i = 0; i < (netmaskcount - 16); i++) {
        mybit[i] = '1';
       }
       String mystr="";
       for(int i=0;i<mybit.length;i++)
       {
        mystr=mystr+mybit[i];
       }
       String returnStrnetwork=inIpArray[0]+"."+inIpArray[1];
       String returnStrBoardAddr="";
       int mytemp=256-Integer.parseInt(mystr, 2);
       int temp=inIpArray[2]/mytemp;
       returnStrBoardAddr=returnStrnetwork+"."+String.valueOf(mytemp*(temp+1)-1)+".255";
       returnStrnetwork=returnStrnetwork+"."+(temp)*mytemp+".0";
       return new String[]{returnStrnetwork,returnStrBoardAddr};
      }
     }
     
     public String[] getCNetworkNumber(int netmaskcount) {
      char[]  mybit= { '0', '0', '0', '0', '0', '0', '0', '0' };
      for (int i = 0; i < (netmaskcount - 24); i++) {
       mybit[i] = '1';
      }
      String mystr="";
      for(int i=0;i<mybit.length;i++)
      {
       mystr=mystr+mybit[i];
      }
      int[] inIpArray = getStrBlock(ip);
      String returnStrnetwork=inIpArray[0]+"."+inIpArray[1]+"."+inIpArray[2];
      String returnStrBoardAddr="";
      int mytemp=256-Integer.parseInt(mystr, 2);
      int temp=inIpArray[3]/mytemp;
      returnStrBoardAddr=returnStrnetwork+"."+String.valueOf(mytemp*(temp+1)-1);
      returnStrnetwork=returnStrnetwork+"."+(temp)*mytemp;
      return new String[]{returnStrnetwork,returnStrBoardAddr};
     }

     /**
      * @function 得到网络类型(A,B,C,其他)1-A,2-B,3-C,0-其他
      * @return
      */
     public int getSubNetKind() {
      if (getStrBlock(ip)[0] < 128) {
       return 1;
      } else if (getStrBlock(ip)[0] < 192) {
       return 2;
      } else if (getStrBlock(ip)[0] < 224) {
       return 3;
      } else {
       return 0;
      }
     }

     /**
      * @function 得到子网掩码位数
      * @return
      */
     public int getNetBoradMask() {
      int count = 0;
      int[] maskBlockArray = getStrBlock(ipmask);
      for (int i = 0; i < maskBlockArray.length; i++) {
       count = count + getBit(maskBlockArray[i]);
      }
      return count;
     }

     /**
      * @function 将数值转化为2进制
      * @param num
      * @return
      */
     private int getBit(int num) {
      int count = 0;
      String strBit = Integer.toBinaryString(num);
      char[] charBit = strBit.toCharArray();
      // 判断子网掩码的有限性
      for (int i = 0; i < charBit.length; i++) {
       if (charBit[i] == '0') {
        int ss = 0;
        for (int j = i; j < charBit.length; j++) {
         ss = ss + Integer.valueOf(String.valueOf(charBit[j]));
        }
        if (ss > 0) {
         System.err.println(num + "子网掩码错误");
         return count;
        } else {
         return count;
        }
       }
       if (charBit[i] == '1') {
        count++;
       }
      }
      return count;
     }

     /**
      * @function 分割ip或者子网掩码为四段,返回int数组
      * @param mystr
      * @return
      */
     private int[] getStrBlock(String mystr) {
      int[] myArray = new int[4];
      String strReplace = mystr.replace('.', '-');
      String[] myArrayStr = strReplace.split("-");
      for (int i = 0; i < myArrayStr.length; i++) {
       myArray[i] = Integer.valueOf(myArrayStr[i]);
      }
      return myArray;
     }

     public String getIp() {
      return ip;
     }

     public void setIp(String ip) {
      this.ip = ip;
     }

     public String getIpmask() {
      return ipmask;
     }

     public void setIpmask(String ipmask) {
      this.ipmask = ipmask;
     }
    }

    //Junit4用例

    //Filename:TestIpClassify.java

    package com.xiaoqiang.ut;

    import static org.junit.Assert.assertEquals;
    import static org.junit.Assert.assertNotNull;
    import static org.junit.Assert.assertTrue;

    import java.lang.reflect.Field;
    import java.lang.reflect.Method;

    import org.junit.BeforeClass;
    import org.junit.Test;

    import xiaoqiang.main.IpClassify;


    public class TestIpClassify {
     @BeforeClass
     public static void init() {

     }

     @Test
     public void testprivateIp() throws SecurityException, NoSuchFieldException,
       IllegalArgumentException, IllegalAccessException {
      IpClassify a = new IpClassify("10.10.10.10", "255.255.255.0");
      Field f = a.getClass().getDeclaredField("ip");
      f.setAccessible(true);
      String ip = (String) f.get(a);
      assertTrue(ip.equals("10.10.10.10"));
     }

     @Test
     public void testprivateMask() throws SecurityException,
       NoSuchFieldException, IllegalArgumentException,
       IllegalAccessException {
      IpClassify a = new IpClassify("10.10.10.10", "255.255.255.0");
      Field f = a.getClass().getDeclaredField("ipmask");
      f.setAccessible(true);
      String ip = (String) f.get(a);
      assertTrue(ip.equals("255.255.255.0"));
     }

     @Test
     public void testNew() {
      IpClassify a = new IpClassify("10.10.10.10", "255.255.255.0");
      assertNotNull(a);
     }

     @Test
     public void testgetANetworkNumber() throws Exception {
      String[] myIp = { "10.10.10.10,255.255.255.0",
        "10.10.10.10,255.255.0.0", "10.10.10.10,255.0.0.0",
        "10.148.54.175,255.255.254.0", "10.10.10.195,255.255.255.128" };
      String[] myNetNum = { "10.10.10.0,10.10.10.255",
        "10.10.0.0,10.10.255.255", "10.0.0.0,10.255.255.255",
        "10.148.54.0,10.148.55.255", "10.10.10.128,10.10.10.255" };
      for (int i = 0; i < myIp.length; i++) {
       IpClassify a = new IpClassify(myIp[i].split(",")[0], myIp[i].split(",")[1]);
       Method mo = a.getClass().getDeclaredMethod("getBit", int.class);
       mo.setAccessible(true);
       Integer countA[] = { (Integer) mo.invoke(a, 255),
         (Integer) mo.invoke(a, 255), (Integer) mo.invoke(a, 255),
         (Integer) mo.invoke(a, 0) };
       String[] myNetworkNum = a.getANetworkNumber(countA[0] + countA[1]
         + countA[2] + countA[3]);
       assertTrue(myNetworkNum[0].trim().equals(myNetNum[i].split(",")[0].trim()));
       System.out.println(myNetworkNum[0] +" \t"+myNetNum[i].split(",")[0]);
    //   assertTrue(myNetworkNum[1].trim().equals(myNetNum[i].split(",")[1].trim()));
    //   System.out.println(myNetworkNum[1] +" \t"+myNetNum[i].split(",")[1]);
      }

     }

     @Test
     public void testPrivategetBit() {
      try {
       IpClassify a = new IpClassify("10.10.10.10", "255.255.255.0");
       Method mo = a.getClass().getDeclaredMethod("getBit", int.class);
       mo.setAccessible(true);
       int myNum[] = { 0, 128, 192, 224, 240, 248, 252, 254, 255 };
       for (int i = 0; i < myNum.length; i++) {
        Object obj = mo.invoke(a, myNum[i]);
        Integer count = (Integer) obj;
        assertTrue(i == count);
       }
      } catch (Exception e) {
       System.out.println(e.toString());
      }
     }

     @Test
     public void testgetip() {
      IpClassify a = new IpClassify("10.10.10.10", "255.255.255.0");
      assertTrue(a.getIp().equals("10.10.10.10"));
     }

     @Test
     public void testgetmask() {
      IpClassify a = new IpClassify("10.10.10.10", "255.255.255.0");
      assertTrue(a.getIpmask().equals("255.255.255.0"));
     }

     @Test
     public void testprivategetStrBlock() {
      try {
       IpClassify a = new IpClassify("10.10.10.10", "255.255.255.0");
       Method mo = a.getClass().getDeclaredMethod("getStrBlock",
         Class.forName("java.lang.String"));
       mo.setAccessible(true);
       Object obj = mo.invoke(a, "10.10.10.10");
       int[] myip = (int[]) obj;
       for (int i = 0; i < myip.length; i++) {
        assertTrue(myip[i] == 10);
       }
      } catch (Exception e) {
       System.out.println(e.toString());
      }
     }

     @Test
     public void testgetSubNetKind() {
      IpClassify a0 = new IpClassify("0.10.10.10", "255.255.255.0");
      IpClassify a1 = new IpClassify("10.10.10.10", "255.255.255.0");
      IpClassify a2 = new IpClassify("127.10.10.10", "255.255.255.0");

      IpClassify b0 = new IpClassify("128.125.14.54", "255.255.255.0");
      IpClassify b1 = new IpClassify("172.125.14.54", "255.255.255.0");
      IpClassify b2 = new IpClassify("191.125.14.54", "255.255.255.0");

      IpClassify c0 = new IpClassify("192.168.1.1", "255.255.255.0");
      IpClassify c1 = new IpClassify("193.168.1.1", "255.255.255.0");
      IpClassify c2 = new IpClassify("223.168.1.1", "255.255.255.0");

      IpClassify t0 = new IpClassify("224.168.1.1", "255.255.255.0");
      IpClassify t1 = new IpClassify("235.168.1.1", "255.255.255.0");
      IpClassify t2 = new IpClassify("255.168.1.1", "255.255.255.0");

      assertEquals(a0.getSubNetKind(), 1);
      assertEquals(a1.getSubNetKind(), 1);
      assertEquals(a2.getSubNetKind(), 1);

      assertEquals(b0.getSubNetKind(), 2);
      assertEquals(b1.getSubNetKind(), 2);
      assertEquals(b2.getSubNetKind(), 2);

      assertEquals(c0.getSubNetKind(), 3);
      assertEquals(c1.getSubNetKind(), 3);
      assertEquals(c2.getSubNetKind(), 3);

      assertEquals(t0.getSubNetKind(), 0);
      assertEquals(t1.getSubNetKind(), 0);
      assertEquals(t2.getSubNetKind(), 0);
     }

     @Test
     public void testsetip() {
      IpClassify a = new IpClassify("10.10.10.10", "255.255.255.0");
      a.setIp("10.10.10.13");
      assertTrue(a.getIp().equals("10.10.10.13"));
     }

     @Test
     public void testsetmask() {
      IpClassify a = new IpClassify("10.10.10.10", "255.255.255.0");
      a.setIpmask("255.255.254.0");
      assertTrue(a.getIpmask().equals("255.255.254.0"));
     }
    }

     

    展开全文
  • Golang 局域网广播消息

    2020-11-03 16:46:40
    消息发送方 server.go package main import ( "bufio" "log" "net" "os" ) func main() { laddr := net.UDPAddr{ IP: net.IPv4(0, 0, 0, 0),//... IP: net.IPv4(192, 168, 1, 255), //局域网广播地址 Por

    消息发送方 server.go

    package main
    
    import (
    	"bufio"
    	"log"
    	"net"
    	"os"
    )
    
    func main() {
    
    	laddr := net.UDPAddr{
    		IP:   net.IPv4(0, 0, 0, 0),//写局域网下分配IP,0.0.0.0可以用来测试
    		Port: 8080,
    	}
    
    	raddr := net.UDPAddr{
    		IP:   net.IPv4(192, 168, 1, 255), //局域网广播地址
    		Port: 8080,
    	}
    
    	conn, err := net.DialUDP("udp", &laddr, &raddr)
    
    	if err != nil {
    		log.Panicln(err.Error())
    	}
    
    	defer conn.Close()
    	scan := bufio.NewScanner(os.Stdin)
    
    	for scan.Scan() {
    		mess := scan.Text()
    		if mess == "quit" {
    			return
    		}
    		_, err := conn.Write([]byte(mess))
    		if err != nil {
    			log.Panicln(err.Error())
    		}
    	}
    }
    
    

    消息接收方:client.go

    package main
    
    import (
    	"log"
    	"net"
    )
    
    func main() {
    	net.InterfaceAddrs()
    	laddr := net.UDPAddr{
    		IP:   net.IPv4(0, 0, 0, 0), //写局域网下分配IP,0.0.0.0可以用来测试
    		Port: 8080,
    	}
    	conn, err := net.ListenUDP("udp", &laddr)
    	if err != nil {
    		log.Panicln(err.Error())
    	}
    	defer conn.Close()
    	buf := make([]byte, 1024)
    	for {
    		n, err := conn.Read(buf)
    		if err != nil {
    			log.Panicln(err.Error())
    		}
    		log.Println(string(buf[:n]))
    	}
    }
    
    
    展开全文
  • 换句话说就是客户端向服务器发送信息,客户端只需要给出服务器的ip地址和端口号,然后将信息封装到一个待发送的报文中并且发送出去。至于服务器端是否存在,或者能否收到该报文,客户端根本不用管。通常我们讨论的...
  • socket的局域网广播

    2017-11-24 18:52:04
    广播 ...3. UDP的广播地址为255.255.255.255 4. 在winsock实现中, 有一个选项对应是否允许广播.linux下必须调用setsockopt打开该选项. 5. 打开后, 用sendto向255.255.255.255发送的数据包全部
  • VC6的基于UDP的局域网广播

    热门讨论 2009-08-17 11:11:19
    用VC6开发的基于UDP的局域网广播。 在交换机和集线器组建的局域网上都测试过。如果无法广播,请关闭防火墙,并设置ip地址
  • java UDP实现局域网广播

    千次阅读 2015-11-07 18:37:09
    关于广播,涉及到MulticastSocket,他用于接收广播的信息,前提是要将它加入到广播组,组播的地址是保留的D类地址从224.0.0.0—239.255.255.255,而且一些地址有特定的用处如,224.0.0.0—244.0.0.255只能用于
  • Unity使用UDP在局域网广播本地IP

    千次阅读 2018-08-24 12:04:45
    想到的办法是通过服务器在局域网广播本地IP地址:  private static Socket sock;  private static IPEndPoint iep1;  private static byte[] data;  private Thread t;  public int...
  • /*---------------------------... * // 文件功能描述:UDP广播IP地址。实现类似CS的局域网房间列表 ---------------------------------------------------*/ using UnityEngine; using System.Collections; using Un
  • 一、实验说明:按照网络拓扑图连接并设置好PC机的IP地址,要求PC1、PC2在VLAN 12上访问,PC3、PC4在VLAN 34上访问,PC1与PC2互联互通,PC3与PC4互联互通,VLan 12 与VLan 34互不相通,以实现隔离局域网广播域。...
  • 局域网广播通信源代码

    千次阅读 2007-04-22 22:08:00
    //recv 接收广播信息void main(void){ SOCKET s; sockaddr_in from,a; WSADATA wsdata; BOOL optval;... //然后赋值给两个地址,一个用来绑定套接字,一个用来从网络上的广播地址接收消息; a.sin_f
  • python 获取局域网内的广播地址

    千次阅读 2016-05-10 13:36:04
    #########计算广播地址 broad_list = [] for j in ip_add: subMask_split = subMask.split( "." ) myIp = (j+ ".1" ).split( "." ) str_cast = "" for i in xrange ( 4 ): xx = ( int (myIp[i])&...
  • 局域网socket广播数据包

    千次阅读 2018-07-30 09:22:31
    本地广播地址就是255.255.255.255,它不经路由转发,发送本地网络下的所有主机,只能在局域网内转发,主要是不用知道目标主机的掩码与网络地址,本地转发同本地网络下的所有主机。 直接广播: 计算方法通过主机...
  • 局域网聊天

    2014-04-15 17:17:26
    在同一个局域网,通过广播IP聊天的程序,把IP改为自己局域网广播地址可以直接运行
  • 有朋友问到局域名网内ip地址“不够用”怎么办?...很多时候企业局域网络出现私网地址不够用了,去掉一个广播地址及一个网络地址后就可能不够用。(0是网络地址不可用, 255是广播地址,除去这2个,可用的就是254个地...
  • 在一个wifi下我的IP是192.168.186.28,要向其他手机广播一个消息,那么广播地址应该是192.168.186.255,可是我这样试来试去都不行,为什么? 然后我又换了一个wifi,我的IP是192.168.0.103,那么广播地址应该是192....
  • 企业办公信息化对网络的依赖则更大。为了提升安全管理和信息化水平,很多企业...一、网络克隆速度太慢“网克(网络克隆)”就是局域网内使用一台服务器通过组播或广播方式向多个客户端同时传送数据,相当于批量操作...
  • 局域网ip地址不够用,这个确实在网络规划与维护中...很多时候企业局域网络出现私网地址192.168.1.x-255不够用了,去掉一个广播地址及一个网络地址后就可能不够用。(0是网络地址不可用, 255是广播地址,除去这2个,可...
  • 关注我,你的眼睛会怀孕有朋友问到局域名网内ip地址“不够用”怎么办?...很多时候企业局域网络出现私网地址192.168.1.x-255不够用了,去掉一个广播地址及一个网络地址后就可能不够用。(0是网络地...
  • 来源: http://www.enet.com.cn/article/2008/0908/A20080908355544.shtml受限的广播 受限的广播地址是255.255.255.255。...在任何情况下,路由器都不转发目的地址为受限的广播地址的数据报,这样的数据报仅出现在本地
  • 局域网的组播和广播

    千次阅读 2018-08-11 13:50:06
    写在前面:项目中,局域网发现协议是通过局域网组播和局域网广播混合实现的。因为单独使用组播或者广播, 都有可能被路由器或者客户端过滤掉,而不能发送到接收方。采用两者并用提高发送消息的成功率。当然了,组播...
  • 本文实例讲述了Android编程实现基于局域网udp广播自动建立socket连接的方法。分享给大家供大家参考,具体如下: android开发中经常会用到socket通讯。由于项目需要,最近研究了一下这方面的知识。 需求是想通过wifi...
  • 本文实例为大家分享了java使用udp模式编写聊天程序的具体代码,供大家参考,具体内容如下java代码:/*使用udp模式,编写...也未加入ui组件这样比较简洁发送端口9998接受端口9999用的是局域网广播地址,所以自己发的消...
  • 本文实例为大家分享了java使用UDP模式编写聊天程序的具体代码,供大家参考,具体内容如下Java代码:/*使用UDP模式,编写...也未加入UI组件这样比较简洁发送端口9998接受端口9999用的是局域网广播地址,所以自己发的消...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,753
精华内容 701
关键字:

局域网广播地址