Linux下使用DNW工具下载镜像

本文主要是介绍Linux下使用DNW工具下载镜像，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1.首先解压缩文件：

# tar xvf dnw_for_linux.tar.gz

另：在Ubuntu下右键解压也很方便

目录如下：

dnw_linux/

dnw_linux/secbulk/

dnw_linux/secbulk/Makefile

dnw_linux/secbulk/secbulk.c

dnw_linux/dnw/

dnw_linux/dnw/dnw.c

其中secbulk.c是PC端USB驱动, dnw.c是写入工具

2 编译并加载secbulk.c内核模块

$cd secbulk

$make -C /lib/modules/`uname -r`/build M=`pwd` modules

编译成功后在当前目录下可以看到secbulk.ko

3.编译完成后，会生成secbulk.ko文件：

# ls

Makefile Module.symvers secbulk.ko secbulk.mod.o

modules.order secbulk.c secbulk.mod.c secbulk.o

4.加载模块到Linux内核：

# sudo insmod ./secbulk.ko （注意要在root权限下）

# dmesg (查看是否加载成功）

secbulk:secbulk loaded

usbcore: registered new interface driver secbulk （看到这样两行就说明成功了）

开机的时候不会自动加载.ko文件，这样每次都要先加载才可以使用，此时将其加入开机脚本，

使其得到自动加载,编辑/etc/init.d/rc.local 在最后加上 insmod /所在路径/secbulk.ko。

5.下面开始编译dnw工具

# cd ../dnw

# gcc -o dnw dnw.c

(编译完成，会看到dnw可执行文件）

6.将文件copy到/usr/local/bin目录

# sudo cp dnw /usr/local/bin

(这样就可以在shell下面直接使用dnw命令了）

secbulk.c

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/fs.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/uaccess.h>#define SECBULK_MAJOR	102
#define SECBULK_MINOR	0
#define DRIVER_NAME	"secbulk"#define BULKOUT_BUFFER_SIZE	512struct secbulk_dev
{struct usb_device *udev;struct mutex io_mutex;char*	bulkout_buffer;__u8	bulk_out_endpointAddr;
};static struct usb_class_driver secbulk_class;static struct usb_device_id secbulk_table[]= {{ USB_DEVICE(0x5345, 0x1234)},{ }
};static struct usb_driver secbulk_driver;
static void secbulk_disconnect(struct usb_interface *interface)
{struct secbulk_dev *dev = NULL;printk(KERN_INFO "secbulk:secbulk disconnected!\n");dev = usb_get_intfdata(interface);if( NULL != dev )kfree(dev);usb_deregister_dev(interface, &secbulk_class);return;
}static ssize_t secbulk_read(struct file *file, char __user *buf, size_t len, loff_t *loff)
{return -EPERM;
}static ssize_t secbulk_write(struct file *file, const char __user *buf, size_t len, loff_t *loff)
{size_t to_write;struct secbulk_dev *dev = file->private_data;int ret;int actual_length;size_t total_writed;total_writed = 0;while(len > 0){to_write = min(len, BULKOUT_BUFFER_SIZE);if(copy_from_user(dev->bulkout_buffer, buf+total_writed, to_write)){printk(KERN_ERR "secbulk:copy_from_user failed!\n");return -EFAULT;	}	ret = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),dev->bulkout_buffer,to_write,&actual_length,3*HZ);if(ret || actual_length!=to_write){	printk(KERN_ERR "secbulk:usb_bulk_msg failed!\n");return -EFAULT;}	len -= to_write;total_writed += to_write;}	return total_writed;
}static int secbulk_open(struct inode *node, struct file *file)
{struct usb_interface *interface;struct secbulk_dev *dev;interface = usb_find_interface(&secbulk_driver, iminor(node));if(!interface)return -ENODEV;dev = usb_get_intfdata(interface);dev->bulkout_buffer = kzalloc(BULKOUT_BUFFER_SIZE, GFP_KERNEL);if(!(dev->bulkout_buffer))return -ENOMEM;if(!mutex_trylock(&dev->io_mutex))return -EBUSY;file->private_data = dev;return 0;
}static int secbulk_release(struct inode *node, struct file *file)
{struct secbulk_dev *dev;dev = (struct secbulk_dev*)(file->private_data);kfree(dev->bulkout_buffer);mutex_unlock(&dev->io_mutex);return 0;
}static struct file_operations secbulk_fops = {.owner 	=	THIS_MODULE,.read 	=	secbulk_read,.write	=	secbulk_write,.open   =	secbulk_open,.release=	secbulk_release,
};static struct usb_class_driver secbulk_class = {.name = 	"secbulk%d",.fops =		&secbulk_fops,.minor_base=	100,
};static int secbulk_probe(struct usb_interface *interface, const struct usb_device_id *id)
{int ret;struct secbulk_dev *dev;struct usb_host_interface *iface_desc;struct usb_endpoint_descriptor *endpoint;int i;printk(KERN_INFO "secbulk:secbulk probing...\n");dev = kzalloc(sizeof(*dev), GFP_KERNEL);if(!dev){ret = -ENOMEM;goto error;}	iface_desc = interface->cur_altsetting;for(i=0; i < iface_desc->desc.bNumEndpoints; i++){endpoint = &(iface_desc->endpoint[i].desc);if(!dev->bulk_out_endpointAddr&& usb_endpoint_is_bulk_out(endpoint)){printk(KERN_INFO "secbulk:bulk out endpoint found!\n");dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;break;}}if(!(dev->bulk_out_endpointAddr)){ret = -EBUSY;goto error;}ret = usb_register_dev(interface, &secbulk_class);if(ret){printk(KERN_ERR "secbulk: usb_register_dev failed!\n");return ret;}		dev->udev = usb_get_dev(interface_to_usbdev(interface));usb_set_intfdata(interface, dev);mutex_init(&dev->io_mutex);return 0;
error:if(!dev)kfree(dev);return ret;
}static struct usb_driver secbulk_driver= {.name=		"secbulk",.probe=		secbulk_probe,.disconnect=	secbulk_disconnect,.id_table=	secbulk_table,.supports_autosuspend=0,
};
static int __init secbulk_init(void)
{int result;printk(KERN_INFO "secbulk:secbulk loaded\n");result = usb_register(&secbulk_driver);if(result){	printk(KERN_ERR "secbulk:usb_register failed: %d", result);return result;}		return 0;
}static void __exit secbulk_exit(void)
{usb_deregister(&secbulk_driver);printk(KERN_INFO "secbulk:secbulk unloaded\n");
}module_init(secbulk_init);
module_exit(secbulk_exit);
MODULE_LICENSE("GPL");

Makefile

obj-m := secbulk.o
secbulk-m := secbulk.o

dnw.c

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>const char* dev = "/dev/secbulk0";int main(int argc, char* argv[])
{unsigned char* file_buffer = NULL;if( 2 != argc ){printf("Usage: dwn <filename>\n");return 1;}int fd = open(argv[1], O_RDONLY);if(-1 == fd){printf("Can not open file - %s\n", argv[1]);return 1;}struct stat file_stat;if( -1 == fstat(fd, &file_stat) ){printf("Get file size filed!\n");return 1;}	file_buffer = (char*)malloc(file_stat.st_size+10);if(NULL == file_buffer){printf("malloc failed!\n");goto error;}if( file_stat.st_size !=  read(fd, file_buffer+8, file_stat.st_size)){printf("Read file failed!\n");goto error;}printf("file name : %s\n", argv[1]);printf("file size : %d bytes\n", file_stat.st_size);int fd_dev = open(dev, O_WRONLY);if( -1 == fd_dev){printf("Can not open %s\n", dev);goto error;}*((unsigned long*)file_buffer) = 0x32000000; 	//load address*((unsigned long*)file_buffer+1) = file_stat.st_size+10;	//file sizeunsigned short sum = 0;int i;for(i=8; i<file_stat.st_size+8; i++){sum += file_buffer[i];}printf("Writing data...\n");size_t remain_size = file_stat.st_size+10;size_t block_size = remain_size / 100;size_t writed = 0;while(remain_size>0){size_t to_write = remain_size > block_size ? block_size:remain_size;if( to_write != write(fd_dev, file_buffer+writed, to_write)){printf("failed!\n");return 1;}remain_size -= to_write;writed += to_write;printf("\r%d%\t %d bytes     ", writed*100/(file_stat.st_size+10), writed);fflush(stdout);}	printf("OK\n");return 0;error:if(-1!=fd_dev) close(fd_dev);if(fd != -1) close(fd);if( NULL!=file_buffer )free(file_buffer);return -1;
}