谁有opensolaris中的tcopy.c， 可以付一点辛苦费

木刀客

tcopy.c 的源代码， 是open-solaris中的哦.


henry6123@sohu.com

windoze

1. 
   
2. /*
   
3. * CDDL HEADER START
   
4. *
   
5. * The contents of this file are subject to the terms of the
   
6. * Common Development and Distribution License, Version 1.0 only
   
7. * (the "License").  You may not use this file except in compliance
   
8. * with the License.
   
9. *
   
10. * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
    
11. * or http://www.opensolaris.org/os/licensing.
    
12. * See the License for the specific language governing permissions
    
13. * and limitations under the License.
    
14. *
    
15. * When distributing Covered Code, include this CDDL HEADER in each
    
16. * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
    
17. * If applicable, add the following below this CDDL HEADER, with the
    
18. * fields enclosed by brackets "[]" replaced with your own identifying
    
19. * information: Portions Copyright [yyyy] [name of copyright owner]
    
20. *
    
21. * CDDL HEADER END
    
22. */
    
23. /*
    
24. * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
    
25. * Use is subject to license terms.
    
26. */
    
27. 
    
28. /*        Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T        */
    
29. /*          All Rights Reserved          */
    
30. 
    
31. /*
    
32. * University Copyright- Copyright (c) 1982, 1986, 1988
    
33. * The Regents of the University of California
    
34. * All Rights Reserved
    
35. *
    
36. * University Acknowledgment- Portions of this document are derived from
    
37. * software developed by the University of California, Berkeley, and its
    
38. * contributors.
    
39. */
    
40. 
    
41. #pragma ident        "%Z%%M%        %I%        %E% SMI"
    
42. 
    
43. #include <stdio.h>
    
44. #include <signal.h>
    
45. #include <sys/types.h>
    
46. #include <sys/file.h>
    
47. #include <sys/fcntl.h>
    
48. #include <sys/mtio.h>
    
49. #include <stdlib.h>
    
50. #include <limits.h>
    
51. #include <errno.h>
    
52. 
    
53. char *buff;                                /* buffer for read/write */
    
54. int filen = 1;                                /* file number being processed */
    
55. long count, lcount;                        /* number of blocks for file */
    
56. extern void RUBOUT();
    
57. int nfile;                                /* used for ??? */
    
58. off64_t size, tsize;                        /* number of bytes in file, total */
    
59. int ln;
    
60. char *inf, *outf;
    
61. int copy;
    
62. size_t size_64K = 64 * 1024;
    
63. size_t size_256K = 256 * 1024;
    
64. 
    
65. 
    
66. int
    
67. main(argc, argv)
    
68. char **argv;
    
69. {
    
70.         int        n, nw, inp, outp;
    
71.         struct mtop op;
    
72.         size_t buf_size = size_64K;
    
73. 
    
74.         if (argc <= 1 || argc > 3) {
    
75.                 (void) fprintf(stderr, "Usage: tcopy src [dest]\n");
    
76.                 return (1);
    
77.         }
    
78.         inf = argv[1];
    
79.         if (argc == 3) {
    
80.                 outf = argv[2];
    
81.                 copy = 1;
    
82.         }
    
83.         if ((inp = open(inf, O_RDONLY, 0666)) < 0) {
    
84.                 (void) fprintf(stderr, "Can't open %s\n", inf);
    
85.                 return (1);
    
86.         }
    
87.         if (copy) {
    
88.                 if ((outp = open(outf, O_WRONLY, 0666)) < 0) {
    
89.                         (void) fprintf(stderr, "Can't open %s\n", outf);
    
90.                         return (3);
    
91.                 }
    
92.         }
    
93.         if ((buff = malloc(buf_size)) == NULL) {
    
94.                 (void) fprintf(stderr, "Can't allocate memory for tcopy\n");
    
95.                 return (4);
    
96.         }
    
97.         if (signal(SIGINT, SIG_IGN) != SIG_IGN)
    
98.                 (void) signal(SIGINT, RUBOUT);
    
99.         ln = -2;
    
100.         for (;;) {
     
101.                 count++;
     
102.                 errno = 0;
     
103.                 while ((n = read(inp, buff, buf_size)) < 0 &&
     
104.                     errno == ENOMEM && buf_size < INT_MAX) {
     
105.                         if (buf_size < size_256K)
     
106.                                 buf_size = size_256K;
     
107.                         else
     
108.                                 buf_size *= 2;
     
109.                         free(buff);
     
110.                         if ((buff = malloc(buf_size)) == NULL) {
     
111.                                 (void) fprintf(stderr,
     
112.                                     "Can't allocate memory for tcopy\n");
     
113.                                 return (4);
     
114.                         }
     
115.                         op.mt_op = MTFSF;        /* Rewind to start of file */
     
116.                         op.mt_count = (daddr_t)0;
     
117.                         if (ioctl(inp, MTIOCTOP, (char *)&op) < 0) {
     
118.                                 perror("Read record size");
     
119.                                 return (6);
     
120.                         }
     
121.                         errno = 0;
     
122.                 }
     
123.                 if (n > 0) {
     
124.                         if (copy) {
     
125.                                 nw = write(outp, buff, (size_t)n);
     
126.                                 if (nw != n) {
     
127.                                         (void) fprintf(stderr, "write (%d) !="
     
128.                                             " read (%d)\n", nw, n);
     
129.                                         (void) fprintf(stderr, "COPY "
     
130.                                             "Aborted\n");
     
131.                                         return (5);
     
132.                                 }
     
133.                         }
     
134.                         size += n;
     
135.                         if (n != ln) {
     
136.                                 if (ln > 0)
     
137.                                         if (count - lcount > 1)
     
138.                                                 (void) printf("file %d: records"
     
139.                                                     " %ld to %ld: size %d\n",
     
140.                                                     filen, lcount, count-1, ln);
     
141.                                         else
     
142.                                                 (void) printf("file %d: record"
     
143.                                                     " %ld: size %d\n",
     
144.                                                     filen, lcount, ln);
     
145.                                 ln = n;
     
146.                                 lcount = count;
     
147.                         }
     
148.                 } else {
     
149.                         if (ln <= 0 && ln != -2) {
     
150.                                 (void) printf("eot\n");
     
151.                                 break;
     
152.                         }
     
153.                         if (ln > 0)
     
154.                                 if (count - lcount > 1)
     
155.                                         (void) printf("file %d: records %ld to"
     
156.                                             " %ld: size " "%d\n",
     
157.                                             filen, lcount, count-1, ln);
     
158.                                 else
     
159.                                         (void) printf("file %d: record %ld:"
     
160.                                             " size %d\n", filen, lcount, ln);
     
161.                                 (void) printf("file %d: eof after %ld records:"
     
162.                                     " %lld bytes\n", filen, count-1, size);
     
163.                         if (copy) {
     
164.                                 op.mt_op = MTWEOF;
     
165.                                 op.mt_count = (daddr_t)1;
     
166.                                 if (ioctl(outp, MTIOCTOP, (char *)&op) < 0) {
     
167.                                         perror("Write EOF");
     
168.                                         return (6);
     
169.                                 }
     
170.                         }
     
171.                         filen++;
     
172.                         count = 0;
     
173.                         lcount = 0;
     
174.                         tsize += size;
     
175.                         size = 0;
     
176.                         if (nfile && filen > nfile)
     
177.                                 break;
     
178.                         ln = n;
     
179.                 }
     
180.         }
     
181.         if (copy)
     
182.                 (void) close(outp);
     
183.         (void) printf("total length: %lld bytes\n", tsize);
     
184.         return (0);
     
185. }
     
186. 
     
187. void
     
188. RUBOUT()
     
189. {
     
190.         if (count > lcount)
     
191.                 --count;
     
192.         if (count)
     
193.                 if (count > lcount)
     
194.                         (void) printf("file %d: records %ld to %ld: size"
     
195.                             " %d\n", filen, lcount, count, ln);
     
196.                 else
     
197.                         (void) printf("file %d: record %ld: size %d\n",
     
198.                             filen, lcount, ln);
     
199.         (void) printf("interrupted at file %d: record %ld\n", filen, count);
     
200.         (void) printf("total length: %lld bytes\n", tsize+size);
     
201.         exit(1);
     
202. }
     

复制代码

可以掏辛苦费了。

木刀客

回复 2# windoze


    稍等， 我先编译哈， 一张老人头？？

lxyscls

猫哥威武得一塌糊涂

windoze

回复 3# 木刀客

……唉……算了……在网上花了3分钟搜到的东西……

windoze

话说这个tcopy从Solaris还叫SunOS那会儿起基本上就没改过，你忽然找这个干嘛？

itstx

猫哥号厉害。

木刀客

有一些很古老的磁带。 九轨开盘带， 就想军统间谍录音的那种， 磁带的。  这种磁带到上世纪80年代用的很多， 当时是SCSI接口。
现在有一套SUN的老工作站， 刚好连接磁带机。

不好意思， 瘟毒死下， 连接SCSI磁带机，还能勉强好办， 驱动也勉强能找到。 可是SCSI后的设备的那个跳线的号， 在瘟毒死下不会找设备了。 在网上找了些识别SCSI设备的程序。 吓死人了， 比我要读出磁带数据地程序还常几倍

木刀客

我先solaris那个坛子挂帖， 后来又在solaris档案中心挂帖， 有人看， 无人答。

在这里出现答复，   谢谢猫哥（其实你应该比我小一点）， 就想笑傲江湖的令狐，你好厉害

windoze

回复 8# 木刀客

我猜你说的那个“跳线”应该是设LUN的吧，如果OS找不到设备你看看是不是磁带机的lun和其它SCSI设备冲突了，比如SCSI卡自己要占一个。