HDTenEightyP/NetNews huggingface dataset:
From: DTM102@psuvm.psu.edu
Newsgroups: comp.virus
Subject: OS/2 anti-virus programs (OS/2)
Date: 6 Apr 92 19:55:28 GMT

I think I caught a virus on my hardisk.  It runs OS/2 ver. 1.3 with a
DOS partition.  I have no knowledge of any anti-virus program that
scans OS/2.  I tried to use F-PROT thinking that it may be able to
scan because I have the DOS partition but that did not work.  Please
write me back if you know of any programs that run on OS/2, and where
I can get them.

Thanks

*------------------------------------------------------*
*   David Mojock              dtm102@psuvm.psu.edu     *
*                                                      *
*   Pennsylvania State University,  State College, PA  *
*------------------------------------------------------*
From: cmcl2!mcclb0.med.nyu.edu!huff@uunet.UU.NET (Edward J. Huff)
Newsgroups: comp.virus
Subject: Re: Computer Hazzard Symbol
Date: 11 Apr 92 04:57:09 GMT

linc@tongue1.Berkeley.EDU (Linc Madison) writes:
> C_PUFFER@unhh.unh.edu (Charles Puffer) writes:
> >I have been thinking about the a computer hazzard symbol for some time
> >now and would like to suggest somthing like this.
>
> Personally, I like the standard "biohazard" symbol (a vertical line
> and two lines at 120-degree angles, each splitting into two curved
> lines) as a symbol for computer viruses.  The meaning is reasonably
> unambiguous -- there is very likely not any literal biohazard
> associated with a computer diskette.

Use of the biohazard symbol, like use of the radiation hazard symbol,
is forbidden by regulations where no biohazard exists.  When you discard
the package materials from a radioactive shipment, regulations require
that you deface the radiation hazard symbol prior to disposal (but after
checking with a geiger counter).

The (very valid) purpose of this regulation is to avoid "crying wolf" too
often.  If people see this symbol where no hazard actually exists, they
will tend to ignore it when there is a hazard.

The computer hazard symbol should be considerably different from the
biohazard symbol.
From: werner@cs.utexas.edu (Werner Uhrig)
Newsgroups: comp.virus
Subject: Re: Virus infection tracking
Date: 10 Apr 92 01:19:08 GMT


  (quoting Kevin Hemsley)
> Maybe I am missing something, but I fail to see the value in
> cataloging the source of all incoming diskettes for later use in
> tracking the source of virus infections.  It seems to me that a scan
> of all incomming diskettes will reveal any known viruses and prevent
> an infection in the first place.

	the problem is that your scanner may not be effective
	against an unknown virus (or even against some known ones)
	at the time the diskette arrives.  Later, when the virus-
	alert is sounded, and new tools are available, the intrepid
	sleuth will be able to narrow down the time of infection
	by carefully dating the changes, sometimes by comparing
	against backups (to get a fix on the infection period);

	by having such a log available, one can then narrow down
	things even further...

	it's not the only technique to use, but it seems intuitively
	"promising"...

					Cheers,		---Werner

ps: unfortunately (watch out! pet-pieve coming up! ;-) most toy-operating
    systems on personal computers have very limited (hah! or NONE indeed)
    logging capabilities (which would greatly enhance system administration
    tasks like these...  )
- --
  --(werner@rascal.ics.utexas.edu)--*OR*--(...!uunet!cs.utexas.edu!werner)--
Definition of Foreign Aid:
	"The transfer of money from poor people in rich countries
	to rich people in poor countries"  ---Unknown, probably dead...
From: 72571.3352@CompuServe.COM (Wolfgang Stiller)
Newsgroups: comp.virus
Subject: Re: Which Package is Best? (PC)
Date: 4 Apr 92 10:45:21 GMT
Organization: Lehigh University


 bontchev@fbihh.informatik.uni-hamburg.de (Vesselin Bontchev) writes:

  > The following? But the review of Stealth Bomber was the last article
  > in the bulletin. Or, do you mean the previous review, that of PC
  > Armour? Well, they said quite fairly that it does not provide great

Yes, I did mean the previous review.

  > security and that when you boot from a floppy, the hard disk is not
  > accessible to MS-DOS. It is not, indeed! The fact that the user can
  > start Norton Utilities in /Manintnance mode and do whatever he wishes
  > with the hard disk, using only BIOS calls, is a completely different
  > story... :-)

Exactly!  My complaint was mostly a quibble with the fact that they
gave no clue as to how easily access to the hard disk could be
obtained.  In evaluating a security product, it's critical to be
able to assess the amount of work required to bypass it.  I would
have liked to have seen a better indication of this.

  > > I think anyone who makes claims which can have disastrous results for
  > > their customers deserves more than just anger.  After someone
  > > irretrievably loses some critical programs, will they feel better
  > > because of "angry experts?

  > Well, yes, you are right, but have in mind that the silly claims have
  > been made by the company that markets the product, not by the
  > developers (who have done a pretty good job).

That's true; we can't blame the developers directly, can we?
I have a few products marketed by an independent company and I
insist on maintaining control over how they are presented to the
potential customer (packaging, advertising etc.).  I guess this gets
into a moralistic question.   Do we as programmers just write our
code and then turn it over to others to do with as they please?? I
contend that we have a responsibility to see that the technology we
create is utilized in an appropriate way. (Pardon me if I'm getting
a bit too moralistic or perhaps off topic for Virus-L)

  > > Integrity Master will continue to evolve and learn from its
  > > competition.
  >
  > As somebody wrote on one of the newsgroups, the best thing for the
  > user is if there are two main competing products for the task s/he
  > needs done... :-)

I agree!  There's no one right answer, plus we all benefit from
advancement in technology.

Regards, Wolfgang                                 Wolfgang Stiller
                                                  Stiller Research
                                                  2625 Ridgeway St.
                                                  Tallahassee, FL 32310
                                                  U.S.A.
From: georgep@vice.ico.tek.com (George Pell)
Newsgroups: comp.virus
Subject: Re: The word 'Cascade' in my hardware ?? (PC)
Date: 9 Apr 92 21:51:11 GMT

alamma@craft.camp.clarkson.edu (Munir A. Alam) writes:
+I just recently got Norton Utilties Version 6.0, while checking out all
+the new features, I noticed on System Info under the 'Hardware Interrupts'
+the following:
+
+Number   Address   Name                       Owner
+ -----  ---------  -------------------------  ---------------
+
+IRQ 00  1934:003C  Timer Output 0             DOS System Area
+IRQ 01  1934:0045  Keyboard                   DOS System Area
+IRQ 02  F000:1F1A  [Cascade]                  BIOS
+IRQ 03  F000:1F1A  COM2                       BIOS
+
+Cascade ? Cascade the virus ?
+This was on a 286, IBM PS/2 Model 30. I checked it out (With Norton 6) on
+a friends 386. Same thing......

The PC and the PC-XT had only one interrupt controller chip.  This
turned out to be a major hardware limitation, so when the 286 was
brought out a second interrupt controller chip was included which was
CASCADED (connected) to interrupt 02 (and re-mapped to interrupt 09).

[Cascade] when referring to interrupt 02 is normal.

geo
Newsgroups: comp.programming
From: junio@twinsun.com (Junio Hamano)
Subject: Re: functions & return values (was Re: Reinventing the wheel)
Organization: Twin Sun, Inc.
	<3549@caslon.cs.arizona.edu> <sc5H&#7m6@cs.psu.edu>
	<3582@caslon.cs.arizona.edu>
Date: Sat, 11 Apr 1992 00:45:20 GMT

There are more cases in which { and } pairs might be useful to
denote tuples in C.  Two cases I can think of offhand are:

1. when we want to make up a structure value on the fly.  e.g.

	struct foo { int bar; char *baz; } a;
	a = (struct foo){ 1, "one" };

2. when we want to write a swap macro.  e.g.

	#define SWAP(a,b) ({(a),(b)}={(b),(a)})

GCC already supports 1. (constructor expression).
--
Jun Hamano (junio@twinsun.com)
From: spg@nereid.sunquest.com (Steve Gibbons)
Newsgroups: comp.programming
Subject: Re: Multi-tasking kernel
Date: 13 Apr 92 07:56:00 GMT
Organization: Sunquest Information Systems, Instrument Interfacing
News-Software: VAX/VMS VNEWS 1.4-b1

#   I think you missed my point. You _cannot_ write a multitasking
#   kernel to run in even vaguely portable C, not unless there are some
#   interesting new library routines since I last checked. Of course
#   there are hacks that might work, but setjmp/longjmp alone doesn't
#   suffice, in any language except a normal-order functional language
#   where it turns out to be isomorphic with a continuation (?!).

That's funny.  I'm currently working with a non-preemptive "kernel" written
in 'C' that ports to VAX/VMS, DEC/MIPS, IBM/RS6000, IBM/80386, and SunOS...
Yes, it multi-tasks.  Yes, it's realtime.  Yes, It's basicly an embedded 
system.  No, it's not completely portable/general.  Yes, it does work.
Not a single setjmp/longjmp in the code, either.

I think the key point is what _type_ of multi-tasking one is looking for.

--
Steve (SPG6) spg@sunquest.com
Newsgroups: comp.programming
From: dalamb@qucis.queensu.ca (David Lamb)
Subject: Re:    need a HINT on a C code parsing name-strings
Organization: Computing & Information Science, Queen's University at Kingston
Date: Wed, 15 Apr 1992 18:53:18 GMT

In article <92096.184215DECBC@CUNYVM.BITNET>, <DECBC@CUNYVM.BITNET> writes:
|> I am writing a C code to parse an input string formatted in
|> 'lastname,firstname,middle-initial' of each field is varying
|> length and total length is 30 bytes, into three separate
|> strings, 'lastname,' 'firstname,' and 'middle-initial.'
|> 
|> My code doesn't satisfy the efficiency required by my demanding
|> boss. So, folks, I really appreciate it if u would give me some hints.

I agree with a previous poster (Doug Moore) - we really need more
information to help you out.  It's a little hard to believe efficiency
of this problem could be a big issue, but...

1. If your compiler generates efficient procedure call code, or
   conversely if it treats certain "C library" routines as intrinsics,
   the fastest way to find a comma in an existing string may be to
   call strchr or index, which searches a given string for a given
   character and returns a pointer to that character (or null).
1a.Otherwise, the usual hand-coded way to manipulate strings quickly
   involves code like *(destPointer++) = *(sourcePointer++).
2. If you're allowed to bash the original string, you can overwrite
   the original commas with nulls, avoiding the cost of copying
   characters to new strings.
3. It occurs to me to wonder if you're calling a storage allocator to
   allocate space for the 3 new strings?  This can be VERY slow!  If
   there's some reason you really have to do this, at least allocate a
   31-byte chunk and subdivide it for the contents of the 3 strrings.
Newsgroups: comp.programming
From: cg@myrias.ab.ca (Chris Gray)
Subject: Re: keywords in the symbol table? (Re: Perfect hash summary....)
Summary: avoid multiple lookups/enters
Keywords: symbol table keyword lexical
Organization: Myrias Research Corporation
Date: Fri, 10 Apr 92 19:43:37 GMT

In article <1992Apr9.024922.24759@u.washington.edu> eriksea@carson.u.washington.edu (Erik Seaberg) writes:
>stephen@estragon.uchicago.edu (Stephen P Spackman) writes:
>>*WHY* do people want a lexer that picks up keywords?
>
>IMHO, a lexer shouldn't know anything about symbol tables.  It doesn't
>have anything useful to enter in one except "this identifier has been
>mentioned by name."  And most all of the information in a symbol table
>entry doesn't apply to keywords ("if" doesn't have a type or scope).  A
>parser uses keywords to delimit large constructs; they don't have to look
>like identifiers - I think it makes a lot of sense to give the lexer its
>own fast little table to screen out keywords (if they happen to look like
>identifiers) and leave the more expensive symbol table lookups for when
>they're necessary, and keep the symbol table(s) internal to the parser.

Read what Stephen said again. You will notice that his method results in
exactly one lookup or enter of ANY symbol into the one master table. What
you are suggesting usually ends up with 3, and always at least 2. One is the
first check to see if the symbol is a keyword or not. The other is looking it
up and/or entering it into the main symbol table. Depending on how you did your
block-structured language compiler, you might end up with a whole sequence
of lookups. Which is going to be faster? Note that looking your keywords up
in the main symbol table is quite fast - there are very few of them, and they
are entered into a large, empty table at startup, so they are unlikely to
experience any collisions, hence lookup will not have to do any scanning.
If you don't like the symbol table stuff in the lexer, then move it to a
separate module and call it from the lexer. The fact that keywords don't
need all the stuff that a typical symbol table entry contains is also not
important - the space wasted is trivial compared to the speed gained.

I've done at least (I can't remember!) two compilers this way. One is the
PD Draco compiler for CP/M and AmigaDos, and the other is the C compiler
for Myrias. It works just fine.

Oh yes - you say you want the parser to get a special token for the keywords
and not a symbol token. Of course! When the lexer has looked the symbol up,
it will see an entry that says RESERVED_WORD_XXX, and will then create a
keyword token, and not a symbol token.
-- 
Chris Gray	Myrias Computer Technologies Inc.   (403) 463-1337
	cg@myrias.ab.ca          ...!uunet!myrias!cg
From: dave@cs.arizona.edu (Dave Schaumann)
Newsgroups: comp.programming
Subject: Re: functions & return values (was Re: Reinventing the wheel)
Date: 13 Apr 92 14:18:16 GMT
Organization: U of Arizona CS Dept, Tucson

In article <10212@goanna.cs.rmit.oz.au> ok@goanna.cs.rmit.oz.au (Richard A. O'Keefe) writes:
[my suggestion to use structs deleted]

>Why can't I have what was present years ago in MESA, which is like
>	x: foo; y: bar;
>	procedure quux [] returns [a: foo; b: bar]; ...
>	...
>	[a: x, b: y] := quux [];
>
>This is, after all, the kind of thing one does in ML:
>	let {a: x, b:y} = quux in ...

This would be all right by me; my objection to what has been suggested so
far is that it was yet another order-dependant construct.  The more I write
larger projects, the less I want to have to remember stupid little details
like parameter order.  I know that I can list all my procedure headers and
use that to find out what I need to know.  But I would prefer to be able
to write code without having to consult reference sheets.

Assuming that the return value names were reasonably chosen, I would have
no problem with your syntax (which is really just anonymous structs).

>There are many reasons to want multiple assignment; multiple function
>results is just one of them.

I remain unconvinced of this.  For me, being able to assing structs is
all the `multiple assignment' I have ever needed.  I agree that having
anonymous structs is a great advantage, though.

Just like subroutines give you code encapsulation, structs give you data
encapsulation.  And in the same way that two pieces of code going together
suggests that they should be encapsulated together, I think that two pieces
of data going together suggest that they should be encapsulated together
too.

-- 
Dave Schaumann			dave@cs.arizona.edu
Newsgroups: comp.programming
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Subject: Re: Names
Organization: University of Chicago CILS
Distribution: comp
Date: Sun, 12 Apr 1992 06:57:07 GMT

The conventions I use in C (but I'd defend a parallel scheme wherever
appropriate) are:

general:
	identifiers made out of whole words, each internal word
	starting with a captial letter, likeThis. Underscore used as a
	structuring operator where the language lets you down (in C,
	for instance, you will want identifiers like "colour_orange"
	in enums).

types:
	short, descriptive names that overlap only when in subtyping
	relation (so FileBinary is derived from File). Note that
	Filer is ok because the capitalisation convention
	distinguishes it from FileR which would be some (poorly named)
	file subtype. Type names start with an uppercase letter,
	partly from mathematical convention and partly to avoid (in C)
	the ambiguity between "sizeof(file)" and "sizeof(File)".

variables, constants and functions:
	these are all objects and should follow the same naming
	conventions. If they are part of the implementation of a type,
	they start with the name of the type (so fileEndP rather than
	IsEndOfFile). This makes name conflicts all but impossible and
	has the added benefit of making a whole package sort
	contiguously, which is occasionally useful. It's a little less
	like English, but you can't think in English and write good
	code at the same time anyway.

I tend to choose object names with three levels of detail according to
scope: I use very short and very stylised names (like i and p) for
things like loop iterators that are scoped to internal blocks and are
idiomatic artefacts of the language; ones derived directly from type
names for things at the function level - a complex conjugate function
might well just call its argument "complex". Beyond that, the full
naming convention is used; no distinction between "public" and
"private" function names because I find that that's clear from the
declarations and if you find yourself exporting a previously local
function (this happens frequently since I tend to be zealous about
namespace control but code for the future) it's nice to have little
editing to do.

There are a few standardised cryptic suffixes that I use (maybe I
shouldn't); notably File_ is the type that the public type File is a
pointer to, and colour_ is the cardinality of the enumeration Colour.

Oh, and global variables: never, ever use global variables. Trust me
on this. Never use the "system" types; if you can't be bothered to
introduce a new type for your purpose, at least use names like "Int16"
that follow the naming convention and express your judgment as to the
size that is necessary. But best always to bother.
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------
Newsgroups: comp.programming
From: schwartz@roke.cs.psu.edu (Scott Schwartz)
Subject: Re: Reinventing the wheel
Organization: penn state university, computer science
	<sc5H&#7m6@cs.psu.edu> <1992Apr10.134851.25240@reed.edu>
Date: Fri, 10 Apr 1992 17:23:21 GMT

orpheus@reed.edu (P. Hawthorne) writes:
       I think you're guaranteed to get off on the whole actor premiss. If you
   don't find it to be an elegant form of programming expression, you get
   your money back, an official Functional Language fanatic ID card, and all
   of this fun can be had at little or no physical risk.

Sorry to be dense, but I have no idea what your point is.  Mine is
that it is perfectly logical to write functions as taking M parameters
and returning N parameters, and that it is no problem to implement.  I
don't see how this interferes with the actor model in any way.  I also
don't see how limiting functions to one param/one result interferes
with the actor model either, but that's completely beside the point.
From: dave@cs.arizona.edu (Dave Schaumann)
Newsgroups: comp.programming
Subject: Re: Reinventing the wheel
Date: 9 Apr 92 06:37:15 GMT
Organization: U of Arizona CS Dept, Tucson

In article <STEPHEN.92Apr8204414@estragon.uchicago.edu> stephen@estragon.uchicago.edu (Stephen P Spackman) writes:
|In article <1992Apr08.115757.10212@ibmpcug.co.uk> dylan@ibmpcug.co.uk (Matthew Farwell) writes:
||I agree.  The only thing I don't like about this is doing stuff like
||having to return structures from functions around (in C).  I guess C++
||would help here.  It just seems ugly to pass back a
||{int foobar; char *blurf} instead of a base type.
|
|Only because C doesn't support
|
|	{foobar, blurf} = f(...stuff...);
|
|which it should.

I'm not so sure about that.  I think that far more often than not, when you
wish you could return two values from a function, what you really need to do
is re-examine your data structures, and not redesign the language.

I don't see the problem with functions returning structs.  Given that structs
are a fundamental building block of data structures, it seems ludicrous that
a function should be prohibited from returning one, or that this should somehow
seem `unnatural'.

IMHO, adding some weird baroque syntax to allow multiple values to be returned
into multiple variables is simply not necessary, and would only add a feature
to be exploited by the Obfuscated C Contestants.

-- 
Dave Schaumann			dave@cs.arizona.edu
Newsgroups: comp.programming
From: rfischer@Xenon.Stanford.EDU (Ray Fischer)
Subject: Re: Perfect hash summary....
Organization: Computer Science Department, Stanford University.
Date: Tue, 7 Apr 1992 05:10:42 GMT

stephen@estragon.uchicago.edu (Stephen P Spackman) writes ...
>This may seem like an odd question, but does anyone have a USE for
>minimal perfect hashing? The "obvious" one, in programming languages,
>is somewhat bogus, since in that case you have a symbol table anyway,
>and it's faster and easier just to treat keywords like identifiers
>through until the parser (unless, I suppose, your language has really
>different rules for the two classes so that the lexer is better off
>making the discimination).

Actually it is neither easier nor faster to have the parser rather
than the lexer identify keywords.  Consider all the work that has to 
be done to find a symbol - if there are 200 symbols you'll have to do
some 8 string compares to find out if it's a keyword.  Compare this
with a hash function that only makes one pass through the string and
does one string compare.

Besides, any time I've written a parser it was MUCH easier to have the
lexer figure out what token a string represented rather than try and
do it in the parser.

Ray
rfischer@cs.stanford.edu
Newsgroups: comp.programming
From: stephen@estragon.uchicago.edu (Stephen P Spackman)
Subject: Re: Multi-tasking kernel
Organization: University of Chicago CILS
	<1992Apr11.122628.2131@nuscc.nus.sg>
	<STEPHEN.92Apr11210424@estragon.uchicago.edu>
	<rxvjyd-.jsteele@netcom.com>
	<STEPHEN.92Apr12052026@estragon.uchicago.edu>
	<ROCKWELL.92Apr12182954@socrates.umd.edu>
Date: Mon, 13 Apr 1992 05:33:29 GMT

In article <ROCKWELL.92Apr12182954@socrates.umd.edu> rockwell@socrates.umd.edu (Raul Deluth Miller-Rockwell) writes:
|Stephen P Spackman:
|   I think you missed my point. You _cannot_ write a multitasking
|   kernel to run in even vaguely portable C, not unless there are some
|   interesting new library routines since I last checked. Of course
|   there are hacks that might work, but setjmp/longjmp alone doesn't
|   suffice, in any language except a normal-order functional language
|   where it turns out to be isomorphic with a continuation (?!).
|
|You can write a non-preemptive multitasking kernel to run in portable
|C, and it doesn't really need setjmp/longjmp.  It does require that
|you build your own "function call" protocol, with explicit stack
|management and parameter passing, however.

Sure, and I can write a graph reduction interpreter in portable C
(which is more fun). But it kinda misses the point when you start
writing interpreters!
----------------------------------------------------------------------
stephen p spackman         Center for Information and Language Studies
stephen@estragon.uchicago.edu                    University of Chicago
----------------------------------------------------------------------