nanoBase 1997 user manual 4235 This function helps with the

Transcript

nanoBase 1997 user manual
4235
determinates the horizontal alignment:
"L" all left;
"l" middle left;
"C" center;
"c" center;
"R" all right;
"r" middle right.
determinate the vertical alignment:
"T" top;
"t" up;
"C" center;
"c" center;
"B" bottom;
"b" down.
cHorozontal
cVertical
This function helps with the windows alignment recalculating and modifying nTop , nLeft ,
nBottom and nRight in the way to obtain the desired alignment.
COPYFILE()
COPYFILE( cSourceFile , cTargetFile |cDevice ) ⇒ NIL
the source filename.
the target filename.
the target devicename.
cSourceFile
cTargetFile
cDevice
This function copies the cSourceFile to cTargetFile or to cDevice.
DBAPP()
[
]
] [
]
DBAPP( cFileName , acFields ,
bForCondition , bWhileCondition
nNextRecords ,
nRecord ,
lRest ,
cDriver ) ⇒ NIL
[
[
[
[
[
]
]
cFileName
acFields
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
cDriver
],
]
the filename containing data to append to the active alias.
array of fieldnames indicating the fields that should be updated on the active alias (default is all).
a code block containing the FOR condition to respect for the
data append. Will be appended data that makes the evaluation
of this code block True.
a code block containing the WHILE condition to respect for
the data append. Will be appended data as long as the evaluation of this code block is True: the first time it becomes False,
the data appending is terminated.
if used, means that only the first nNextRecords will be appended.
if used, means that that only the record nRecord will be appended.
this option is not available here also if the function saves a
place for it.
is the optional driver name to use to open the cFileName file.
This function is used to append data to the active alias using data from the cFileName file,
that in this case is a ‘.DBF’ file.
4236
DBCLOSE()
DBCLOSE() ⇒ NIL
It is a substitution function of DBCLOSEALL() to use inside "compiled" macros, as a true
DBCLOSEALL() will close the macro file too.
DBCONTINUE()
DBCONTINUE() ⇒ NIL
This function resumes a pending DBLOCATE().
DBCOPY()
[
] [
]
]
DBCOPY( cFileName , acFields ,
bForCondition , bWhileCondition
nNextRecords ,
nRecord ,
lRest ,
cDriver ) ⇒ NIL
[
[
[
[
[
],
]
]
]
cFileName
acFields
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
cDriver
the target filename for the data contained inside the active
alias.
array of fieldnames indicating the fields that should be used
from the active alias (default is all).
a code block containing the FOR condition to respect for the
data copy. Will be copied the data that makes the evaluation
of this code block True.
the data copy. Will be copied data as long as the evaluation
of this code block is True: the first time it becomes False, the
data copying is terminated.
if used, means that only the first nNextRecords will be
copied.
if used, means that that only the record nRecord will be
copied.
if used means that only the remaining records inside the active
alias are copied.
is the optional driver name to use to open the cFileName file.
This function is used to copy data to cFileName form the active alias.
DBCOPYSTRUCT()
DBCOPYSTRUCT( cDatabase,
cDatabase
acFields
[acFields]
) ⇒ NIL
is a structure ‘.DBF’ file that will be filled with structure information about the active alias.
is an array of fieldnames that should be taken into consideration.
This function creates a structure ‘.DBF’ file copying the structure of the active alias.
DBCOPYXSTRUCT()
DBCOPYXSTRUCT( cExtendedDatabase ) ⇒ NIL
cExtendedDatabase
is a structure ‘.DBF’ file that will be filled with structure information about the active alias, accepting extended structure
informations.
4237
This function creates a structure ‘.DBF’ file copying the structure of the active alias. This
function accept non-standard structure, that is, the extended structure available inside Clipper.
DBDELIM()
[
] [
]
DBDELIM( lCopyTo , cFileName , cDelimiter , acFields ,
bForCondition , bWhileCondition ,
nNextRecords , nRecord , lRest
) ⇒ NIL
[
[
] [
] [
]
] [
]
if True the function work copying data to cFileName from the
active alias, if False the function work appending data from
cFileName to the active alias.
the filename containing data to append to the active alias or
to use as the target of the data copy from the active alias.
the delimiter string (or character) used to separate fields inside
cFileName .
array of fieldnames indicating the fields of the active alias that
should be taken into consideration (default is all).
a code block containing the FOR condition to respect. The operation will be made for all records that respect the condition.
a code block containing the WHILE condition to respect. The
first time it becomes False, the operation is terminated.
if used, means that only the first nNextRecords will be appended/copied.
if used, means that that only the record nRecord will be appended/copied.
if used means that only the remaining records will be taken
into consideration.
lCopyTo
cFileName
cDelimiter
acFields
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
This function is used to append data to the active alias using data from the cFileName
file or to copy data into cFileName using the active alias as the source. cFileName is a
delimited ASCII file.
DBISTATUS()
DBISTATUS() ⇒ cDBInformations
This function returns the informations on the active alias in a text form.
DBISTRUCTURE()
DBISTRUCTURE() ⇒ cTextStructure
| NIL
This function returns the structure information on the active alias in a text form.
DBJOIN()
DBJOIN( cAlias , cDatabase,
acFields , bForCondition
[
cAlias
cDatabase
acFields
] [
]
) ⇒ NIL
the name of the alias to use to merge with records from the
active alias.
the target ‘.DBF’ filename.
the array of fieldnames which represent the projection of
fields form both Aliases into the new ‘.DBF’ file. If not specified, all fields from the primary work area are included in the
target ‘.DBF’ file.
This function creates a new database file by merging selected records and fields form
two work areas (Aliases) based on a general condition. It works by making a complete
4238
pass through the secondary work area cAlias for each record in the primary work area
(the active alias), evaluating the condition for each record in the secondary work area.
When bForCondition is evaluated True, a new record is created in the target database file
cDatabase using the fields specified from both work areas inside acFields .
DBLABELFORM()
[
] [
] [
] [ ]
] [
] [ ] [
DBLABELFORM( cLabel , lToPrinter , cFile ,
lNoConsole , bForCondition , bWhileCondition
nNextRecords , nRecord , lRest , lSample
⇒ NIL
[
[
],
])
is the name of the label file (.LBL) that contains the label
format definition.
if True, the output is copied to printer (‘LPT1:’).
if present, it is the name of a ASCII file where the output is
copied.
if True, the output is not sent to the console.
a code block containing the FOR condition to respect for label
print. Only the records contained inside the active alias that
respect the condition will be used for labels.
the label print. The first time that the condition is False, the
label print terminates.
if used, means that only the first nNextRecords will be used.
if used, means that that only the record nRecord will be used.
alias will be used.
if True displays test labels as rows of asterisks.
cLabel
lToPrinter
cFile
lNoConsole
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
lSample
This function prints labels to the console.
DBLIST()
[
[ ]
[
[
[
],
DBLIST( lToDisplay
lAll ,
bForCondition
nNextRecords
lToPrinter ,
lToDisplay
abListColumns
lAll
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
lToPrinter
cFileName
abListColumns ,
], [bWhileCondition ],
], [nRecord], [lRest],
] [cFileName ] )
if True the printout is sent to the console screen.
is an array of columns expressions to list.
if True prints all the records contained inside the active alias.
a code block containing the FOR condition to respect. Only
the records contained inside the active alias that respect the
condition will be used for list.
first time that the condition is False, the list terminates.
alias will be used.
if True, the output is copied to printer (‘LPT1:’).
if present, it is the name of a ASCII file where the output is
copied.
This function prints a list of records to the console.
4239
DBLOCATE()
[
] [
]
DBLOCATE( bForCondition , bWhileCondition ,
) ⇒ NIL
[
] [
] [
]
condition will be taken into consideration.
first time that the condition is False, the locate terminates.
alias will be used.
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
This function searches sequentially for the first record matching the FOR and WHILE conditions. Once a DBLOCATE() has been issued you can resume the search from the current
record pointer position with DBCONTINUE().
The WHILE condition and the scope (nNextRecord , nRecord and lRest ) apply only to the
initial DBLOCATE() and are not operational for any subsequent DBCONTINUE() call.
DBOLDCREATE()
DBOLDCREATE( cDatabase, cExtendedDatabase ,
cDriver , lNew , cAlias
) ⇒ NIL
[
] [
] [
]
is the name of the new database file, with an optional drive and
directory, specified as a character string. If specified without
an extension (.dbf) is assumed.
is a ‘.DBF’ file containing the structure information of the file
to create.
specifies the replaceable database driver (RDD) to use to process the current work area. cDriver is the name of the RDD
specified as a character expression.
if True the newly created ‘.DBF’ file is opened using the next
available work area making it the current work area (the active
alias).
if lNew is set to True, this is the alias name to use to open the
file.
cDatabase
cExtendedDatabase
cDriver
lNew
cAlias
This function is a old database function (superseded form DBCREATE() ) that creates a
database file from the structure information contained inside a structure file.
DBPACK()
DBPACK() ⇒ NIL
This function eliminates definitively the active alias records previously signed for deletion.
It works only if the active alias is opened in exclusive mode.
DBSDF()
[
]
]
] [ ]
DBSDF( lCopyTo , cFileName , acFields ,
[
[
lCopyTo
cFileName
] [
] [
) ⇒ NIL
if True the function works copying data to cFileName from
the active alias, if False the function work appending data
from cFileName to the active alias.
the filename containing data to append to the active alias or to
use as the target of the data copy from the active alias.
4240
array of fieldnames indicating the fields of the active alias that
should be taken into consideration (default is all).
a code block containing the FOR condition to respect. The operation will be made for all records that respect the condition.
first time it becomes False, the operation is terminated.
if used, means that only the first nNextRecords will be appended/copied.
if used, means that that only the record nRecord will be appended/copied.
if used means that only the remaining records will be taken
into consideration.
acFields
bForCondition
bWhileCondition
nNextRecord
nRercord
lReset
This function is used to append data to the active alias using data from the cFileName file
or to copy data into cFileName using the active alias as the source. cFileName is a SDF
ASCII file.
DBSORT()
[
] [
] [
]
DBSORT( cDatabase, acFields ,
[
[
]
] [
]
) ⇒ NIL
the ‘.DBF’ file to create.
the array of fields to be used to create the new sorted
cDatabase file.
first time that the condition is False, the sort terminates.
if used, means that only the first nNextRecords inside the active alias will be used.
alias will be used.
cDatabase
acFields
bForCondition
bWhileCondition
nNextRecord
nRecord
lRest
Copy the active alias to a ‘.DBF’ file in sorted order.
DBTOTAL()
[
]
DBTOTAL( cDatabase, bKey, acFields ,
[
[
cDatabase
bKey
acFields
bForCondition
bWhileCondition
nNextRecords
nRecord
lRest
] [
] [
]
] [
]
) ⇒ NIL
the ‘.DBF’ file to create that will contain the copy of summarised records.
the code block key expression that should correspond to the
key expression of the active index of the active alias.
the array of fields to be used to create the new cDatabase file.
first time that the condition is False, the sort terminates.
if used, means that only the first nNextRecords inside the active alias will be used.
alias will be used.
4241
This function summarises records by key value to a ‘.DBF’ file. It sequentially process the
active alias scanning the specified scope of records. Records with the same key will be
summarised inside the destination ‘.DBF’ file. The value of numeric fields of records with
the same key are added.
DBUPDATE()
DBUPDATE( cAlias , bKey,
[lRandom ], [bReplacement ]
)
is the alias containing data to be used to update the active
alias.
is a code block expression using information form the cAlias
to obtain a key to refer to the active alias.
if True, allows record in the cAlias to be in any order. In this
case, the active alias must be indexed with the same key as
bKey.
is the code block that will be executed when records matches:
it should contains the criteria for data update.
cAlias
bKey
lRandom
bReplacement
This function updates the active alias with data from another .DBF file.
Example:
dbUpdate( "INVOICE", {|| LAST}, .T.,;
{|| FIELD->TOTAL1 := INVOICE->SUM1,;
FIELD->TOTAL2 := INVOICE->SUM2 } )
DBZAP()
DBZAP() ⇒ NIL
This function erases immediately all the records contained inside the active alias.
DISPBOXCOLOR()
DISPBOXCOLOR(
[nColorNumber ], [cBaseColor]
) ⇒ cColor
may be 1 or 2 and are the two color used to create shadowed
borders. 1 is usually used for the left and top line; 2 is used
for the right and bottom line.
is the starting color string. The default is the actual color.
nColorNumber
cBaseColor
This function return a color string used for DISPBOXSHADOW() the function that create
a shadowed border around a screen window.
DISPBOXSHADOW()
DISPBOXSHADOW( nTop , nLeft , nBottom , nRight ,
cBoxString , cColor1 , cColor2 ) ⇒ NIL
[
] [
nTop , nLeft , nBottom and nRight
cBoxString
cColor1
cColor2
] [
]
are the screen coordinate where the box is to be displayed.
is the box string containing the character to use to build the
box. Default is a single line box.
is the color string to use for the left and top side of the box.
is the color string to use for the right and bottom side of the
box.
This function draws a screen box like DISPBOX() but allowing the variation of colors
around the border to simulate a sort of shadow.
4242
DIR()
DIR(
[cFileSpec], [lDrives], [lDirs], [lFiles],
[lNoDirReturn ], [nSortColumn ] ) ⇒ cPathname
cFileSpec
lDrives
lDirs
lFiles
the filename or Pathname, also with wildcards, to be searched.
true (‘.T.’) means: include drives letters.
true (‘.T.’) means: include directory names.
true (‘.T.’) means: include file names.
true (‘.T.’) means: do not return the shown directory if [ Esc ]
is used to exit.
the column number to use to sort the list. The columns are:
Name = 1,
Size = 2,
Date = 3,
Time = 4,
Attribute = 5.
It is not possible to sort for extention.
lNoRirReturn
nSortColumn
It is a window function useful to search a file or a directory. The complete pathname of the
selected file is returned.
DOC()
DOC(
[cTextFileName ]
cTextFileName
) ⇒ NIL
can contain the text file to open and edit; if empty, the editing
of ‘UNTITLED.TXT’ will start.
It is the nB Text editor useful for small text files (less then 64K) and contains a complete
menu that can be started with F10 .
[ ]
Attention: doc() should not be used inside macros.
DOTLINE()
DOTLINE() ⇒ NIL
This function is a "dot" command line useful for calculations resolution. The dot-line content may be passed to the keyboard buffer.
DTEMONTH()
Date of month
DTEMONTH( nMonth , cLanguage ) ⇒ cMonth
nMonth
cLanguage
the month number.
the language name.
This function translates the nMonth number into the month name translated using the
cLanguage language.
DTEWEEK()
Date of week
DTEWEEK( nWeek , cLanguage ) ⇒ cWeek
nWeek
is the week number (1 is Sunday, 7 is Saturday) to be translated into text.
4243
is the language name into which the week must be expressed.
At the moment it works only for Italian, so cLanguage can
only contain "ITALIANO".
cLanguage
This function translates the week number into the week name translated using the
cLanguage language.
EX()
Execute
EX( cFileMacro ) ⇒ nExitCode
Executes the macro file cFileName . The extention must be specified.
cFileMacro may be the name of a "compiled" macro or a text macro file.
GET()
GET( @aGetList ,
nTop , nLeft ,
{ |x| iif( pcount() > 0, Var := x, Var ) }
cGetPicture , cColorString ,
bPreExpression , bValid
)
[
[
[
] [ ]
] [
] [
]
]
aGetList
nTop and nLeft
Var
cGetPicture
cColorString
bPreExpression
bValid
is the get list array that will be increased with this get().
define the starting position of this get object on the screen.
is the variable that is to be edited with this get. Var is in fact
sent to the GET() function using a code block.
is the get picture to use for Var .
is the color string to use for the get.
is a code block that will be evaluated before the get object
will became active. It must result True to obtain that the get
object became active.
is a code block that will be evaluated after the get object is
edited. It must result True to obtain that the get object may
become inactive.
Create screen editing masks.
GVADD()
Get validation add
GVADD( @cField , cAdd ) ⇒ .T.
cField
cAdd
the field to fill with more data.
is the string to be added to the content of cField .
This function is to be used inside GETs for pre/post validation, when a the content of a field
should be added with more data.
cField is returned with the same length as before to avoid troubles with current and future
GETs.
GVDEFAULT()
Get validation default
GVDEFAULT( @cField , cDefault ) ⇒ .T.
@cField
cDefault
the field to check and if empty correct with cDefault .
is the default value to be used to replace cField .
4244
This function is to be used inside GETs for pre/post validation, when a field should have a
default value.
GETs.
GVFILEDIR()
Get validation file directory
GVFILEDIR( @cWildName ) ⇒ .T.
is the file name taken from the current get to be used for search
with DIR().
cWildName
This function is to be used inside GETs for pre validation: the cWildName is a file name
with wild cards that can be searched with the DIR() function after that a specific key is
pressed.
cWildName is returned with the same length as before to avoid troubles with current and
future GETs.
GVFILEEXIST()
GVFILEEXIST( @cNameToTest ,
[cExtention ]
) ⇒ lSuccess
is the file name taken from the current get to test for existence.
is the normal extention of the file.
@cNameToTest
cExtention
This function is to be used inside GETs for post validation: the file name have to exist.
cNameToTest is returned with the same length as before to avoid troubles with current and
future GETs.
GVFILEEXTENTION()
GVFILEEXTENTION( @cName , cExt ) ⇒ .T.
the file name to be eventually corrected with file extention.
the file extention to use as default.
@cName
cExt
This function is to use inside GETs for pre/post validation, when the content of a field
should contain a file name that should be corrected adding a default extention if not given
from the user.
GVSUBST()
GVSUBST( @cField , cSubst ) ⇒ .T.
the field to be replaced with cSubst .
is the string to be used to replace the content of cField .
@cField
cSubst
This function is to use inside GETs for pre/post validation, when the content of a field
should be replaced with other data.
GETs.
HTF()
HTF(
[nInitialRecord ]
) ⇒ NIL
4245
is the record number where to start the Help Text File browse.
Default is the actual record pointer.
nInitialRecord
This function browse a Help Text File that must be already opened and be the active alias.
ISFILE()
ISFILE( cName ) ⇒ lFileExists
is the file name (with or without path) to be checked for existence.
cName
This function returns true (‘.T.’) if the file cName exists. The difference between this
function and the standard FILE() function is that ISFILE() checks for wildcards before. If
cName contains wildcards, the result is false (‘.F.’).
ISWILD()
ISWILD( cName ) ⇒ lIsWild
is the file name (with or without path) to be checked for wildcards presence.
cName
This function returns true (‘.T.’) if cName contains wildcards.
ISMEMVAR()
ISMEMVAR( cName ) ⇒ lIsMemvar
is the name of a possible memvar.
cName
This function returns true (‘.T.’) if the cName is a declared Memvar.
ISCONSOLEON()
ISCONSOLEON() ⇒ lConsoleIsOn
This function returns true (‘.T.’) if the console will show the result of QOUT() and
QQOUT().
ISPRINTERON()
ISPRINTERON() ⇒ lPrinterIsOn
This function returns true (‘.T.’) if the default printer will report the the result of QOUT()
and QQOUT().
The default printer is ‘PRN:’ or ‘LPT1:’. If SET ALTERNATE TO is configured to send
outputs to ‘LPT2:’ or another printer, the function will report false (‘.F.’).
KEYBOARD()
KEYBOARD(
[cString]
) ⇒ NIL
This function stuff a string into the keyboard buffer.
LISTWINDOW()
[
]
] [ ] [
] [
] [
]
LISTWINDOW( acMenuItem , cDescription ,
nTop , nLeft , nBottom , nRight ,
cColorTop , cColorBody
) ⇒ nPosition
[
[
acMenuItem
]
is the character array containing the list of choices.
4246
is the header to be shown at the top window.
are the window coordinates.
is the color to use for window header and footer.
is the color to use for the window body that is the space where
the text appears.
cDescription
nTop , nLeft , nBottom , nRight
cColorTop
cColorBody
This function is an similar to achoice(), but it shows a header and footer, and it saves the
screen, acting like a window.
MEMOWINDOW()
[
] [
] [
] [
] [
] [
] [
]
]
MEMOWINDOW( cVar , cDescription , nTop , nLeft ,
nBottom , nRight , cColorTop , cColorBody ,
lEditMode , nLineLength , nTabSize
) ⇒ cVar
[
[
] [
]
is the character field (variable) to be edited.
is the header to be shown at the top window.
are the window coordinates.
is the color to use for window header and footer.
is the color to use for the window body that is the space where
the text appears.
is equivalent to memoedit().
cVar
cDescription
nTop , nLeft , nBottom , nRight
cColorTop
cColorBody
lEditMode
nLineLength
nTabSize
This function lets you easily edit a long character field (memo) defining automatically a
simple window and providing a simple help.
MEMPUBLIC()
MEMPUBLIC( cMemvarName
|acMemvarNames
cMemvarName
acMemvarNames
) ⇒ NIL
is the name of the PUBLIC variable to create (max 10 characters).
is an array of PUBLIC variable names to create (max 10 characters).
Creates a PUBLIC variables or a group of variables.
MEMRELEASE()
MEMRELEASE( cMemvarName |acMemvarNames ) ⇒ NIL
cMemvarName
acMemvarNames
is the name of the PUBLIC variable to be released.
is an array of PUBLIC variable names to be released.
This function releases a previously created PUBLIC variables or a group of variables.
MEMRESTORE()
MEMRESTORE( cMemFileName ,
cMemFileName
lAdditive
[lAdditive]
) ⇒ NIL
the memory file (.MEM) to load from disk.
if True causes memory variables loaded from the memory file
to be added to the existing pool of memory variables. If False,
the existing memory variables are automatically released.
4247
Retrieve memory variables form a memory file (.MEM).
MEMSAVE()
MEMSAVE( cMemFileName ,
[cSkeleton ], [lLike]
) ⇒ NIL
the memory file (.MEM) where public variables should be
saved.
the skeleton mask for defining a group of variables. Wildcard
characters may be used: _*_ and _?_.
if True, the variables grouped with cSkeleton are saved, else
only the other variables are saved.
cMemFileName
cSkeleton
lLike
Saves memory variables to a memory file (.MEM).
MENUPROMPT()
MENUPROMPT( @aoGet,
nRow , nCol ,
cPrompt , bBlock
[
[
] [ ]
] [
]
) ⇒ NIL
is an array of get objects where a new get is added by
MENUPROMPT(). These gets are read only.
are the screen coordinates where the menu prompt will appear.
is the menu prompt string.
is the code block to execute when the cursor is on the current
menu prompt. It is usually a code block that shows a message
somewhere on the screen.
aoGet
nRow and nCol
cPrompt
bBlock
This function should substitute the @...PROMPT command and handle the mouse.
MENUTO()
MENUTO( aoGet, nPos ) ⇒ nChoice
array of get objects.
starting position to be edited.
aoGet
nPos
Like MENU TO. It returns the selected menu item created with MENUPROMPT(). It supports the mouse.
MESSAGELINE()
MESSAGELINE(
⇒ NIL
[cMessage], [cColor], [nPosTop], [nPosLeft ]
)
the message to be displayed.
the color string.
the starting position where the string message would appear
on the screen. Default values are respectively ROW() and
COL().
aMessage
cColor
nPosTop and nPosLeft
MESSAGELINE() is a function that display a message on the screen on the selected position. If cMessage is NIL, the message is eliminated from screen restoring the previous
screen content.
MOUSESCRSAVE()
[
] [nLeft ], [nBottom ], [nRight ]
MOUSESCRSAVE( nTop ,
⇒ cSavedScreen
)
4248
are the screen coordinates that will be to save the screen.
This function works line SAVESCREEN() but it hide the mouse cursor before a screen save
is made.
MOUSESCRRESTORE()
[
] [
MOUSESCRRESTORE( nTop , nLeft
cScreen
) ⇒ cSavedScreen
[
], [nBottom ], [nRight ],
]
cScreen
are the screen coordinates where the saved screen will be restored.
is the previously saved screen to restore.
This function works line RESTSCREEN() but it hide the mouse cursor before a screen
restore is made.
PICCHRMAX()
PICCHRMAX(
[nCol], [nMaxCol ]
) ⇒ cPictureString
is the starting position on the screen for the get field.
is the end position on the screen of the get field.
nCol
nMaxCol
This function is useful when a character field is to be used on a get object. The generated
picture will be the of the maximum possible extention, eventually with scroll.
QUIT()
QUIT() ⇒ NIL
Terminates program execution.
READ()
[
] [aButtons ], [lReadOnly]
READ( aoGet, nPos ,
⇒ lUpdated
)
is the array of get objects.
is the starting position.
is the array of buttons.
if True, get fields cannot be modified; the default value is
False.
aoGet
nPos
aButtons
lReadOnly
This function is made to substitute the READMODAL() allowing the use of the mouse.
The array aButtons is made with the help of the function BUTTON().
RF()
RF( cFRMName ,
nNext , nRecord , lRest , lPlain ,
cbHeading , lBeforeEject , lSummary ,
lDate , acExtra
) ⇒ NIL
[
[
[
[
] [
]
] [
] [ ] [
] [
] [
] [
]
cFRMName
bForCondition
bWhileCondition
nNext
nRecord
]
]
the form (.FRM) file to use to print the active alias.
code block for the FOR condition.
code block for the WHILE condition.
see REPORT FORM.
see REPORT FORM
4249
see REPORT FORM
if true (‘.T.’), force the print in a simple way.
additional header in character or code block form. If a code
block is sent, the final result must be a character string.
if true (‘.T.’), force a form feed before the print.
if true (‘.T.’), force a summary print only.
if false (‘.F.’), force the print without date at the top of page.
a character array that may be used for translating standard
printed report form words and to add vertical and horizontal
separations. The default value of acExtra is:
acExtra [1] "Page No."
acExtra [2] "** Subtotal **"
acExtra [3] "* Subsubtotal *"
acExtra [4] "*** Total ***"
acExtra [5] " " vertical column separation
axExtra [6] "" horizontal separation: no separation.
lRest
lPlain
cbHeading
lBeforeEject
lSummary
lDate
acExtra
This function does the same work of REPORT FORM or __ReportForm or dbReportForm,
but it prints where qout() and qqout() print.
RPT()
RPT( cText ) ⇒ NIL
This function prints the text contained into cText using print commands. This function
accepts other parameters here not described, as they are not to be used for macro purpose.
The printing is made using QOUT() and QQOUT(), this way it is sensible to the "alternate"
file definition.
RPTMANY()
RPTMANY( cText ,
⇒ NIL
[bWhileCondition ], [bForCondition ]
)
is the text to be printed.
is a code block for a WHILE condition to respect for the
records to print.
is a code block for a FOR condition to respect for the records
to print.
cText
bWhileCondition
bForCondition
This function prints the text contained into cText many times: one for every record contained into the active alias.
RPTTRANSLATE()
RPTTRANSLATE( cText ) ⇒ cTranslatedText
This function translates once cText replacing variables with memvars or Fields.
RUN()
RUN( cCommand ) ⇒ NIL
This function start execution of cCommand in a DOS session. It works only if there is
enough available memory.
SAY()
SAY( nTop , nLeft , Expr ,
cSayPicture , cColorString
[
] [
]
) ⇒ NIL
4250
define the starting position on the screen where the Expr
should be displayed.
is an expression that will be solved and displayed.
is the picture to use to display Expr .
is the color string to use.
nTop and nLeft
nLeft
cSayPicture
cColorString
This function displays the result of Expr on the screen on the desired position.
SETCOLORSTANDARD()
[nColor], [cColor|acColor]
cPreviousColor|acPreviousColor
SETCOLORSTANDARD(
⇒
)
is the color number to take into consideration:
0 All colors
1 Base
2 Menu
3 Head
4 Body (Say - Get)
5 Button (Mouse buttons)
6 Message
7 Alert
the color string to be associated with nColor .
it the color array
nColor
cColor
acColor
This function is a way to handle colors inside the application. The functions that display
something use a default color depending on what they does. These colors may be changed
with SETCOLORSTANDARD(), all together or only one.
SETFUNCTION()
SETFUNCTION( nFunctionKey , cString ) ⇒ NIL
the number of the function key ( 1=F1, 12=F12) to be assigned.
the character string.
nFunctionKey
cString
This function assigns a character string to a function key (obsolete).
SETMOUSE()
SETMOUSE(
[lShow]
)⇒ lPrevious
True shows the mouse cursor, False hide the mouse cursor,
NIL reports only the status.
lShow
This function is made to show, hide or report only the mouse cursor status.
SETOUTPUT()
[
]
SETOUTPUT( cPeriperal|aPeripheral
⇒ aPrevious_Output_Peripherals
cPeripheral
aPeripheral
)
is the new output peripheral for qout() and qqout() functions.
are the new output peripherals configurations for qout() and
qqout() functions.
nB is organised in the way to have only one output peripheral at the time. This function
4251
help to make order inside SET CONSOLE, SET PRINTER and SET ALTERNATE.
If cPeripheral contains:
"CON"
SET CONSOLE is set to ON,
SET PRINTER is set to OFF,
SET ALTERNATE is set to OFF;
"PRN"
SET CONSOLE is set to OFF,
SET PRINTER is set to ON,
SET ALTERNATE is set to OFF;
"LPT1"
same as "PRN";
otherwise
SET CONSOLE is set to OFF,
SET PRINTER is set to OFF,
SET ALTERNATE is set to ON,
SET ALTERNATE TO is set to cPeripheral .
aPeripheral is organised this way:
aPeripheral [1] = _SET_CONSOLE
aPeripheral [2] = _SET_PRINTER
aPeripheral [3] = _SET_ALTERNATE
aPeripheral [4] = _SET_ALTFILE
aPeripheral [5] = _SET_EXTRA
aPeripheral [6] = _SET_EXTRAFILE
This function is necessary because SET ALTERNATE alone is not enough to print on the
screen when the peripheral name is "CON" or to print on the printer when the peripheral
name is "PRN" or "LPT1". In fact, in the first case, ROW() and COL() will not be updated,
in the second case, PROW() and PCOL() will not be updated.
This function returns an array organised in the same way as aPeripheral is, that shows the
active output configuration.
SETRPTEJECT()
SETRPTEJECT(
[lbEject]
) ⇒ lPreviousEjectMode
This function is used to set the eject mode after every page print for RPT(). If single sheet
paper is used, then SETRPTEJECT(.T.) must be set; for continuous paper, SETRPTEJECT(.F.) is correct. The default value is .F..
lbEject
logical or code block, is the eject mode to set. Default is no
change, the starting value is ‘.F.’
SETRPTLINES()
SETRPTLINES() ⇒ nRemainingLines
This function is used to report the number of lines available before the completion of the
page print for RPT().
SETVERB()
Set verbose
4252
[
SETVERB( cSpecifier , xNewSetting
⇒ xPreviousValueSet
], [lOpenMode]
)
a word that defines the kind of set is going to be considered.
is the new value to set up.
used only for some kind of set.
cSpecifier
xNewSetting
lOpenMode
This function is analogue to SET() but it uses a character string (with cSpecifier ) and not a
number to select the set. This is made to make easier the work with macros.
cSpecifier may contain:
"EXACT"
"FIXED"
"DECIMALS"
"DATEFORMAT"
"EPOCH"
"PATH"
"DEFAULT"
"EXCLUSIVE"
"SOFTSEEK"
"UNIQUE"
"DELETED"
"CANCEL"
"TYPEAHEAD"
"COLOR"
"CURSOR"
"CONSOLE"
"ALTERNATE"
"ALTFILE"
"DEVICE"
"EXTRA"
"EXTRAFILE"
"PRINTER"
"PRINTFILE"
"MARGIN"
"BELL"
"CONFIRM"
"ESCAPE"
"INSERT"
"EXIT"
"INTENSITY"
"SCOREBOARD"
"DELIMITERS"
"DELIMCHARS"
"WRAP"
"MESSAGE"
"MCENTER"
SETVERB("EXACT") (obsolete)
SETVERB( "EXACT",
[lExact]
) ⇒ lPrevious
If lExact is True, it forces exact comparison of character strings, including length. If it is
False, character strings are compared until the left string length is exhausted; that is that ""
(the null string) is equal to any other string.
4253
Please note that the == operator is a comparison operator for exact match and using it,
SETVERB("EXACT", ‘.F.’) will not work.
The starting value is True; the recommended value is True.
SETVERB("FIXED")
SETVERB( "FIXED",
[lFixed]
) ⇒ lPrevious
If lFixed contains True, numeric values are displayed ever with a fixed number of decimal
digits, depending on the value set by SETVERB("DECIMALS").
The starting value is False.
The recommended value is False: if you have to display a fixed number of decimal digits it
is better to define a good display picture.
SETVERB("DECIMALS")
SETVERB( "DECIMALS",
[nDecimals]
) ⇒ nPrevious
nDecimals is the number of digits to display after the decimal position. This set is enabled
of disabled with SETVERB("FIXED").
The starting value is 8.
SETVERB("DATEFORMAT")
SETVERB( "DATEFORMAT",
[cDateFormat]
) ⇒ cPrevious
cDateFormat is a character expression that specifies the date format.
The starting value is "dd/mm/yyyy".
Some date format examples:
"mm/dd/yyyy"
"yyyy.mm.dd"
"dd/mm/yyyy"
"dd/mm/yyyy"
"dd.mm.yyyy"
"dd-mm-yyyy"
"yyyy/mm/dd"
"mm-dd-yyyy"
AMERICAN
ANSI
BRITISH
FRENCH
GERMAN
ITALIAN
JAPAN
USA
SETVERB("EPOCH")
SETVERB( "EPOCH",
[nYear]
) ⇒ nPrevious
nYear specifies the base year of 100-year period in which all dates containing only two
year digits are assumed to fall.
SETVERB("PATH")
SETVERB( "PATH",
[cPath]
) ⇒ cPrevious
cPath identifies the paths that nB uses when searching for a file not found in the current
directory. The list of paths can be separated by commas or semicolons.
The starting value is "".
SETVERB("DEFAULT")
SETVERB( "DEFAULT",
[cPath]
) ⇒ cPrevious
cPath identifies the default disk drive and directory.
4254
The starting value is "".
SETVERB("EXCLUSIVE")
SETVERB( "EXCLUSIVE",
[lExclusive ]
) ⇒ lPrevious
If lPath is True, the default database (.DBF) file open is made in exclusive mode; in the
other case, in shared mode.
The starting value is True.
SETVERB("SOFTSEEK")
SETVERB( "SOFTSEEK",
[lSoftSeek ]
) ⇒ lPrevious
If lSoftSeek is True, if a DBSEEK() index search fails, the record pointer is moved to the
next record with a higher key. If it is False, in case of a DBSEEK() index search failure, the
record pointer is moved at EOF().
SETVERB("UNIQUE") (obsolete)
SETVERB( "UNIQUE",
[lUnique]
) ⇒ lPrevious
If lUnique is True, during creation or update of ‘.DBF’ indexes, if two or more records are
found with the same key, only the first record will be included inside the index.
If lUnique is False, duplicated record keys are allowed.
SETVERB("DELETED")
SETVERB( "DELETED",
[lDeleted]
) ⇒ lPrevious
If lDeleted is True, record signed for deletion are not filtered, that is, these are still normally
visible as they were not deleted. In the other case, they hare (in most cases) hidden to the
user.
SETVERB("CANCEL")
SETVERB( "CANCEL",
[lCancel]
) ⇒ lPrevious
If lCancel is True, enables [ Alt+c ] and [ Ctrl+Break ] as termination keys. In the other case,
not.
SETVERB("TYPEAHEAD")
SETVERB( "TYPEAHEAD",
[nTypeAhead ]
) ⇒ nPrevious
nTypeAhead is the number of keystrokes the keyboard buffer can hold from a minimum of
zero to a maximum of 4096.
SETVERB("COLOR")
SETVERB( "COLOR",
[cColorString]
) ⇒ cPrevious
nColorString defines the normal screen colors. There are five couple of colors, but only
three are really operative:
standard
enhanced
border
background
unselected
This is the standard color used for screen output.
This is the color used for highlighted screen output.
Normally unused.
Normally unused.
This is the color used for GET fields without focus.
4255
The default color string is "BG+/B,N/W,N/N,N/N,W/N" that is:
bright Cyan on Blue
Black on White
Black on Black
Black on Black
White on Black
standard
enhanced
border
background
unselected
The following table explains the use of letters inside the color string. Note that the plus sign
(+) means high intensity, the star (*) means blink and that + and * can be allowed only to
the first letter inside a couple.
Color
Black
Blue
Green
Cyan
Red
Magenta
Brown
White
Gray
Bright Blue
Bright Green
Bright Cyan
Bright Red
Bright Magenta
Bright Brown
Bright White
Black
Inverse Video
Blank
Letter
N, Space
B
G
BG
R
RB
GR
W
N+
B+
G+
BG+
R+
RB+
GR+
W+
U
I
X
Monochrome
Black
Underline
White
White
White
White
White
White
Black
Bright Underline
Bright White
Bright White
Bright White
Bright White
Bright White
Bright White
Underline
Inverse Video
Blank
SETVERB("CURSOR")
SETVERB( "CURSOR",
[lCursor]
) ⇒ lPrevious
If lCursor is True, the cursor is showed, else it is hidden.
SETVERB("CONSOLE")
SETVERB( "CONSOLE",
[lConsole]
) ⇒ lPrevious
If lConsole is True, the output of console commands is displayed on the screen, else it is
not.
SETVERB("ALTERNATE")
SETVERB( "ALTERNATE",
[lAlternate]
) ⇒ lPrevious
If lAlternate is True, the output of console commands is send also to a standard ASCII text
file.
SETVERB("ALTFILE")
SETVERB( "ALTFILE",
⇒ cPrevious
[cAlternateFilename ], [lAdditive]
)
4256
If SETVERB("ALTERNATE") is True, the output of the console is send also to
cAlternateFilename , a standard ASCII file.
If lAdditive is True, the output is appended to the ASCII file if it already exists, else it is
erased first.
SETVERB("DEVICE")
SETVERB( "DEVICE",
[cDevice]
) ⇒ cPrevious
cDevice is the name of the device where SAY() will display its output.
The starting value is "SCREEN", the alternative is "PRINTER".
The recommended value is "SCREEN".
SETVERB("EXTRA")
SETVERB( "EXTRA",
[lExtra]
) ⇒ lPrevious
If lExtra is True, the output of console commands is send also to a standard ASCII text file.
SETVERB("EXTRAFILE")
SETVERB( "EXTRAFILE",
⇒ cPrevious
[cExtraFilename ], [lAdditive]
)
If SETVERB("EXTRA") is True, the output of the console is send also to cExtraFilename ,
a standard ASCII file.
If lAdditive is True, the output is appended to the ASCII file if it already exists, else it is
erased first.
SETVERB("PRINTER")
SETVERB( "PRINTER",
[lPrinter]
) ⇒ lPrevious
If lPrinter is True, the output of console commands is also printed, else it is not.
SETVERB("PRINTFILE")
SETVERB( "PRINTFILE",
[cPrintFileName ]
) ⇒ cPrevious
cPrintFileName is the name of the printer peripheral name.
The starting value is "" (null string).
SETVERB("MARGIN")
SETVERB( "MARGIN",
[nPageOffset ]
) ⇒ nPrevious
nPageOffset is the positive number of column to be used as a left margin for all printer
output.
SETVERB("BELL")
SETVERB( "BELL",
[lBell]
) ⇒ lPrevious
If lBell is True, the sound of the bell is used to get the attention of the user when some
wrong actions are made.
4257
SETVERB("CONFIRM")
SETVERB( "CONFIRM",
[lConfirm ]
) ⇒ lPrevious
If lConfirm is False, the GET is simply terminated typing over the end of the get field; in
the other case (True), the GET is terminated only pressing an "exit key". The starting value
is True.
SETVERB("ESCAPE")
SETVERB( "ESCAPE",
[lEscape]
) ⇒ lPrevious
If lEscape is True, the [ Esc ] key is enabled to be a READ exit key, in the other case not.
The recommended value is True.
SETVERB("INSERT")
SETVERB( "INSERT",
[lInsert]
) ⇒ lPrevious
If lInsert is True, the data editing is in INSERT mode, in the other case, it is in OVERWRITE mode.
SETVERB("EXIT")
SETVERB( "EXIT",
[lExit]
[ ]
) ⇒ lPrevious
[
]
If lExit is True, Up and Down key may be used as exit key when the cursor is (respectively) on the first or on the last GET field. In the other case not.
The recommended value is False.
SETVERB("INTENSITY")
SETVERB( "INTENSITY",
[lIntensity ]
) ⇒ lPrevious
If lIntensitiy is True, the display of standard and enhanced display colors are enabled. In
the other case, only standard colors are enabled.
The recommended value is True.
SETVERB("SCOREBOARD")
SETVERB( "SCOREBOARD",
[lScoreboard]
) ⇒ lPrevious
If lScoreboard is True, the display of messages from READ() and MEMOREAD() is allowed; in the order case not.
The recommended value is False: nB do not support scoreboard.
SETVERB("DELIMITERS")
SETVERB( "DELIMITERS",
[lDelimiters]
) ⇒ lPrevious
If lDelimiters is True, GET variables appear on the screen delimited with the delimiter
symbols. In the other case, GET variables are not delimited this way, but only with the use
of different colors.
The recommended value is False: the use of delimiters creates one more trouble when
designing a screen mask.
4258
SETVERB("DELIMCHARS")
SETVERB( "DELIMCHARS",
[cDelimterCharacters]
) ⇒ cPrevious
cDelimterCharacters are the delimiter characters used to delimit a GET field when
SETVERB("DELIMITERS") is True.
The starting value is "::".
SETVERB("WRAP")
SETVERB( "WRAP",
[lWrap]
) ⇒ lPrevious
If lWrap is True, the wrapping of the highlight in MENUs should be active, but this option
is actually not active and all works as it is False.
SETVERB("MESSAGE")
SETVERB( "MESSAGE",
[nMessageRow ]
) ⇒ nPrevious
nMessageRow is the row number where the @..PROMPT message line should appear on
the screen. This option is not supported.
SETVERB("MCENTER")
SETVERB( "MCENTER",
[lMessageCenter]
) ⇒ lPrevious
If lMessageCenter is True, the @..PROMPT message line should appear centered on the
screen. This option is not supported.
STRADDEXTENTION()
STRADDEXTENTION( cName , cExt ) ⇒ cCompleteName
cName
cExt
the file name (with or without path) that is probably without
extention.
the extention that must be added to cName if it has not one.
This function check cName for the presence of an extention. It it has not one, cExt will be
added.
STRCUTEXTENTION()
STRCUTEXTENTION( cName ) ⇒ cName
cName
the file name (with or without path) that is probably with extention.
This function check cName for the presence of an extention. It it has one, the extention is
removed.
STRDRIVE()
STRDRIVE( cName ) ⇒ cDrive
cName
the file name (with or without path) that contains the drive
letter.
This function tries to extract the drive letter information from cName .
4259
STREXTENTION()
STREXTENTION( cName ) ⇒ cExtention
the file name (with or without path) that contains an extention.
cName
This function tries to extract the extention information from cName .
STRFILE()
STRFILE( cName ) ⇒ cFileName
cName
the file name with or without path.
This function tries to extract the file name without path from cName .
STRFILEFIND()
STRFILEFIND( cName , cPath ) ⇒ cFileName
cName
cPath
the file name or pathname containing the file name to search
inside the cPath list.
a list of paths separated with semicolon (just like Dos does),
where cFile should be searched.
If your file is to be found on different possible positions, this function search the first place
where the file is found and returns a valid pathname to that file.
STRGETLEN()
STRGETLEN( xExpr , cPicture ) ⇒ nFieldLength
xExpr
cPicture
a generic expression.
the picture string.
This function returns the length of field when using xExpr with cPicture .
STRLISTASARRAY()
STRLISTASARRAY( cList ,
cList
cDelimiter
[cDelimiter]
) ⇒ aList
a character string containing a list separated with cDelimiter .
the delimiter used to separate the elements contained inside
the list.
This function transform a character string list into an array.
STROCCURS()
STROCCURS( cSearch , cTarget ) ⇒ nOccurrence
cSearch
cTarget
the search string to find inside cTarget .
the string to be searched for the presence of cSearch .
This function returns the number of occurrence that cSearch is contained inside cTarget .
STRPARENT()
STRPARENT( cName ) ⇒ cParentPath
cName
the pathname.
4260
This function tries to return a parent path from cName .
STRPATH()
STRPATH( cName ) ⇒ cPath
the pathname.
cName
This function tries to extract the path from cName .
STRTEMPPATH()
STRTEMPPATH() ⇒ cTempPath
This function returns a temporary path searching for possible definitions inside the environmental variables.
STRXTOSTRING()
STRXTOSTRING( xVar ,
[cType]
) ⇒ cTrasformed_to_string
is the data of any type to be converted into string.
is the type of the data contained inside xVar .
xVar
cType
This function returns xVar transformed into a character string.
TB()
TB(
[nTop], [nLeft ], [nBottom ], [nRight ],
[acCol], [acColSayPic],
[acColTopSep], [acColBodySep], [acColBotSep],
[acColHead], [acColFoot],
[alColCalc],
[abColValid],
[abColMsg],
[cColor], [abColColors],
[nFreeze],
[lModify],
[lAppend],
[lDelete],
[lButtons | aButtons ] ) ⇒ NIL
nTop , nLeft , nBottom , nRight defines the screen area where browse have to take place.
acCol
acColSayPic
acColTopSep
acColBodySep
acColBotSep
acColHead
acColFoot
alColCalc
abColValid
abColMsg
cColor
is the columns array to be included into the browse.
is the picture array.
is the top separation array: default is chr(194)+chr(196).
is the body separation array: default is chr(179).
is the bottom separation array: default is chr(193)+chr(196).
is the header array for every column.
is the footer array for every column.
is the array that identify the calculated column (not editable).
True (‘.T.’) means calculated.
is the validation array that specify when a field is properly
filled. The condition must be specified in code block format.
is the message array that permits to show information at the
bottom of browse area. The array must be composed with
code blocks which result with a character string.
is the color string: it may be longer than the usual 5 elements.
abColColors
nFreeze
lModify
lDelete
lButtons
aButtons
aButtons [n ][1] N
aButtons [n ][2] N
aButtons [n ][3] C
aButtons [n ][4] B
4261
is the color code block array. The code block receive as parameter the value contained inside the field and must return
an array containing two numbers: they correspond to the two
color couple from cColor.
indicates the number of columns to be left frozen on the left
side.
indicates whether the browse can modify data.
indicates whether the browse can delete and recall records.
if True, default buttons are displayed.
array of buttons.
the n th button row position;
the n th button column position;
the n th button text;
the n th button code block.
This function, called without parameters, starts the browse of the active alias, and if relations are established, the browse includes also related data.
Please note that due to an unresolved problem, the field names contained inside acCol
should better contain also the alias (ALIAS->FIELD_NAME). See also the examples.
TEXT()
TEXT( cText ) ⇒ NIL
Shows the text contained into cText .
TGLINSERT()
TGLINSERT() ⇒ NIL
Toggle the global insert mode and the cursor shape.
TIMEX2N()
TIMEX2N(
[nHH ], [nMM ], [nSS ]
nHH
nMM
nSS
) ⇒ nTime
is the number of hours.
is the number of minutes.
is the number of seconds.
This function calculate the "time number" that is a number representing days and/or portion
of a day: 1 is 1 day or 24 hours, 0.5 is 12 hours, and so on.
TIMEN2H()
TIMEN2H( nTime ) ⇒ nHours
nTime
is the "time number" that is a number representing days and/or
portion of a day: 1 is 1 day or 24 hours, 0.5 is 12 hours, and
so on.
This function returns the integer number of hours contained inside nTime .
TIMEN2M()
TIMEN2M( nTime ) ⇒ nMinutes
4262
so on.
nTime
This function returns the integer number of minutes contained inside nTime after subtracting the hours.
TIMEN2S()
TIMEN2S( nTime ) ⇒ nSeconds
so on.
nTime
This function returns the number of seconds (with eventual decimals) contained inside
nTime after subtracting the hours and the minutes.
TRUESETKEY()
TRUESETLEY( nInkeyCode , bAction ) ⇒ .T.
This function is equivalent to SETKEY() but it returns always ‘.T.’
WAITFILEEVAL()
WAITFILEEVAL( lClose ) ⇒ .T.
Shows a wait bar calling WAITPROGRESS() for operation on records of a database.
If there is no index active, it is equivalent to WAITPROGRES(RECNO()/LASTREC()).
if an index is active, this cannot work, so an increment for each call is made: WAITPROGRES((nIncrement++)/LASTREC()).
This function must be closed calling it with the lClose parameter to true (‘.T.’). This way,
internal counters are closed and WAITPROGRESS() is closed too.
WAITFOR()
WAITFOR(
[cMessage]
) ⇒ NIL
Shows cMessage until it is called again. The wait window is closed when called without
parameter or with NIL.
WAITPROGRESS()
WAITPROGRESS(
[nPercent]
) ⇒ .T.
Shows a wait bar on the screen top depending on the value contained into nPercent .
nPercent starts form 0 and ends to 1 (100%). If a value of one or more, or NIL is passed,
the wait window is closed.
371.16 Normal command substitution
Clipper works only with functions and commands that are converted into function using the
‘STD.CH’. Here are described some command replacement that can be used also with nB macros.
?
[exp_list]
qout([exp_list])
?
4263
[exp_list]
qqout([exp_list])
??
@BOX
[COLOR cColorString]
nRight , [cnBoxString ], [cColorString ])
@ nTop , nLeft , nBottom , nRight BOX cnBoxString
dispbox(nTop , nLeft , nBottom ,
@TO
[COLOR cColorString]
dispbox(nTop , nLeft , nBottom , nRight , 2 [,cColorString ])
@ nTop , nLeft TO nBottom , nRight [COLOR cColorString ]
dispbox(nTop , nLeft , nBottom , nRight , 1 [,cColorString ])
@ nTop , nLeft CLEAR [TO nBottom , nRight ]
scroll([nTop ], [nLeft ], [nBottom , nRight ])
@ nTop , nLeft TO nBottom , nRight DOUBLE
setpos(nRow , nCol )
@GET
[
]
] [COLOR
@ nTop , nLeft GET Var PICTURE cGetPicture
,→ VALID lPostExpression
[
cColorString
] [WHEN
lPreExpression
setpos(nTop , nLeft )
[
]
aadd( GetList, _GET_( Var , "Var ", cGetPicture , {|| lPostExpression } ,←,→ {|| lPreExpression } ):display() ) atail(GetList):colorDisp(cColorString )
[
]
@SAY
@ nTop , nLeft SAY exp
[COLOR
cColorString
]
devpos(nTop , nLeft )
devout(exp
[,
]
cColorString )
@ nTop , nLeft SAY exp PICTURE cSayPicture
[COLOR
devpos(nTop , nLeft )
devoutpic(exp , cSayPicture ,
APPEND
APPEND BLANK
dbappend()
CLEAR
CLEAR
Scroll()
SetPos(0,0)
ReadKill(.T.)
GetList := {}
CLEAR GETS
ReadKill(.T.)
GetList := {}
CLEAR SCREEN
Scroll()
SetPos(0,0)
| CLS
[cColorString])
cColorString
]
]
←-
4264
CLOSE
CLOSE
dbCloseArea()
CLOSE idAlias
idAlias ->( dbCloseArea() )
CLOSE ALTERNATE
Set(19, "")
CLOSE DATABASES
dbCloseAll()
CLOSE INDEXES
dbClearIndex()
COMMIT
COMMIT
dbCommitAll()
COUNT
[
] [WHILE
][ ]
COUNT TO idVar FOR lForCondition
,→ RECORD nRecord
REST
ALL
[
][
lWhileCondition
] [NEXT
nNextRecords
dbeval( {||idVar :=idVar +1}, {||lForCondition }, {||lWhileCondition },←,→ nNextRecords , nRecord , lRest )
DEFAULT
DEFAULT xVar TO xDefaultValue
DEFAULT( @xVar , xDefaultValue ) ⇒ xVar
DELETE
DELETE
dbDelete()
[
] [WHILE lWhileCondition ] [NEXT
] [ALL]
DELETE FOR lForCondition
,→ RECORD nRecord
REST
[
][
nNextRecords
dbeval( {||dbDelete()}, {||lForCondition }, {||lWhileCondition },←,→ nNextRecords , nRecord , lRest )
DELETE FILE xcFile
ferase( cFile )
EJECT
EJECT
qqout( chr(13) )
ERASE
ERASE xcFile
ferase( cFile )
FIND
FIND xcSearchString
dbSeek( cSearchString )
GO
[ ]
GO TO
nRecord
dbgoto(nRecord )
[ ]
GO TO
BOTTOM
dbGoBottom()
]←-
]←-
[ ]
GO TO
4265
TOP
dbgotop()
INDEX ON
[
][
]
INDEX ON expKey TO xcIndexName
UNIQUE
FOR lForCondition ←,→ WHILE lWhileCondition
EVAL lEvalCondition
EVERY nRecords
[
] [[
][
]] [ASCENDING|
]
DESCENDING
[
] [
]
]
[
ordCondSet( cForCondition , bForCondition , , bWhileCondition
,→ bEvalCondition , nRecords , RECNO(), , , , lDescending )
[
] [
],←-
ordCreate( cIndexName , , cExpKey , bExpKey , lUnique )
READ
READ
ReadModal(GetList)
GetList := {}
READ SAVE
ReadModal(GetList)
RECALL
RECALL
dbRecall()
[
] [WHILE lWhileCondition ] [NEXT
] [ ] [ALL]
RECALL FOR lForCondition
,→ RECORD nRecord
REST
[
nNextRecords
dbeval( {||dbRecall()}, {||lForCondition }, {||lWhileCondition },←,→ nNextRecords , nRecord , lRest )
REINDEX
REINDEX
[EVAL
] [EVERY nRecords]
, [bEvalCondition ], [nRecords ],
lEvalCondition
ordCondSet(, , ,
, , , , , , )
ordListRebuild()
RENAME
RENAME xcOldFile TO xcNewFile
frename( cOldFile , cNewFile )
REPLACE
[
][
][ ][ ]
idField1 := exp1 [, idField2
]
REPLACE idField1 WITH exp1 , idField2 WITH exp2 ... ←,→ FOR lForCondition
WHILE lWhileCondition
NEXT nNextRecords
,→ RECORD nRecord
REST
ALL
[
[
][
]
dbeval( {||
:= exp2 ... },←,→{||lForCondition }, {||lWhileCondition }, nNextRecords ,←,→ nRecord , lRest )
REPLACE idField1 WITH exp1
idField1 := exp1
RESTORE
RESTORE SCREEN FROM cScreen
restscreen( 0, 0, Maxrow(), Maxcol(), cScreen )
SAVE
SAVE SCREEN TO cScreen
cScreen := savescreen( 0, 0, maxrow(), maxcol() )
]←-
]←-
4266
SEEK
[SOFTSEEK]
expSearch [, lSoftSeek ]
SEEK expSearch
dbSeek(
)
SELECT
SELECT xnWorkArea
|
idAlias
|
dbSelectArea( nWorkArea
cIdAlias )
SET
SET ALTERNATE TO xcFile
[ADDITIVE]
Set( 19, cFile , lAdditive )
SET ALTERNATE ON
Set( 18, "ON"
SET BELL ON
| "OFF" |
| OFF |
Set( 26, "ON"
SET COLOR
| OFF |
lToggle )
xlToggle
| "OFF" |
| COLOUR
xlToggle
lToggle )
TO (cColorString)
SetColor( cColorString )
SET CONFIRM ON
Set( 27, "ON"
| OFF |
xlToggle
| "OFF" |
SET CONSOLE ON
| OFF |
lToggle )
xlToggle
Set( 17, "ON"
| "OFF" |
SET CURSOR ON
| OFF |
lToggle )
xlToggle
| 0 | iif( lToggle ,
FORMAT [TO] cDateFormat
SetCursor( 1
SET DATE
1, 0 ) )
Set( 4, cDateFormat )
SET DECIMALS TO
Set( 3, 0 )
SET DECIMALS TO nDecimals
Set( 3, nDecimals )
SET DEFAULT TO
Set( 7, "" )
SET DEFAULT TO xcPathspec
Set( 7, cPathspec )
SET DELETED ON
Set( 11, "ON"
| OFF |
xlToggle
| "OFF" |
SET DELIMITERS ON
lToggle )
| OFF |
| "OFF" | lToggle
DELIMITERS TO [DEFAULT]
Set( 33, "ON"
SET
xlToggle
Set( 34, "::" )
SET DELIMITERS TO cDelimiters
Set( 34, cDelimiters )
)
| PRINTER
SET DEVICE TO SCREEN
Set( 20, "SCREEN"
4267
| "PRINTER"
)
SET EPOCH TO nYear
Set( 5, nYear )
SET ESCAPE ON
| OFF |
Set( 28, "ON"
| "OFF" |
xlToggle
SET EXACT ON
| OFF |
Set( 1, "ON"
| "OFF" |
SET EXCLUSIVE ON
Set( 8, "ON"
lToggle )
xlToggle
lToggle )
| OFF |
| "OFF" |
xlToggle
lToggle )
SET FILTER TO
dbclearfilter()
SET FILTER TO lCondition
dbsetfilter( bCondition , cCondition )
SET FIXED ON
| OFF |
xlToggle
| "OFF" | lToggle )
TO [xcIndex [, xcIndex1 ... ] ]
Set( 2, "ON"
SET INDEX
ordListClear()
ordListAdd( cIndex )
ordListAdd( cIndex1 )
...
SET INTENSITY ON
| OFF | xlToggle
| "OFF" | lToggle
nInkeyCode [TO]
Set( 31, "ON"
SET KEY
)
SetKey( nInkeyCode , NIL )
SET KEY nInkeyCode TO
[idProcedure]
SetKey( nInkeyCode , { |p, l, v| idProcedure(p, l, v)} )
SET MARGIN TO
Set( 25, 0 )
SET MARGIN TO
[nPageOffset ]
Set( 25, nPageOffset )
SET MESSAGE TO
Set( 36, 0 )
Set( 37, .F. )
SET MESSAGE TO
[nRow [CENTER | CENTRE]]
Set( 36, nRow )
Set( 37, lCenter )
SET ORDER TO
[nIndex ]
ordSetFocus( nIndex )
SET PATH TO
Set( 6, "" )
[xcPathspec [, cPathspec1 ... ] ]
cPathspec [, cPathspec1 ... ] )
SET PATH TO
Set( 6,
4268
SET PRINTER ON
Set( 23, "ON"
| OFF | xlToggle
| "OFF" | lToggle
)
SET PRINTER TO
Set( 24, "" )
SET PRINTER TO
[xcDevice|xcFile [ADDITIVE]]
|
Set( 24, cDevice cFile , lAdditive )
SET RELATION TO
dbclearrelation()
[
SET RELATION TO expKey1 INTO xcAlias1
, TO expKey2 INTO xcAlias2 ...
ADDITIVE
[ [ ]
[
]
]
]
if !lAdditive
dbClearRel()
end
dbSetRelation( cAlias1 , {|| expKey1},
dbSetRelation( cAlias2 , {|| expKey2},
SET SCOREBOARD ON
Set( 32, "ON"
Set( 9, "ON"
)
)
| OFF | xlToggle
| "OFF" | lToggle
SET SOFTSEEK ON
["expKey1 "]
["expKey1 "]
)
| OFF | xlToggle
| "OFF" | lToggle
)
SET TYPEAHEAD TO nKeyboardSise
Set( 14, nKeyboardSise )
SET UNIQUE ON
| OFF | xlToggle
Set( 10, "ON"
| "OFF" | lToggle
SET WRAP ON
)
| OFF | xlToggle
Set( 35, "ON"
| "OFF" | lToggle
)
SKIP
SKIP
[nRecords] [ALIAS
[idAlias|nWorkArea
->
](
|
idAlias nWorkArea
[
]
]
dbSkip( nRecords ) )
STORE
STORE value TO variable
variable := value
SUM
[
]
[
] [FOR lForCondition ]←] [RECORD nRecord] [REST] [ALL]
[, idVar2 :=idVar2 +nExp2 ...] },←-
SUM nExp1
, nExp2 ... TO idVar1 , idVar2 ...
,→ WHILE lWhileCondition
NEXT nNextRecords
[
][
dbeval( {||idVar1 :=idVar1 +nExp1
,→{||lForCondition }, {||lWhileCondition }, nNextRecords , nRecord , lRest )
UNLOCK
UNLOCK
dbUnlock()
UNLOCK ALL
dbUnlockAll()
4269
USE
USE
dbclosearea()
[
]
USE xcDatabase ←,→ INDEX xcIndex1
, xcIndex2 ...
[
[
] [ALIAS
] [VIA cDriver]]
dbUseArea( [lNewArea ], [cDriver],
[dbSetIndex( cIndex1 )]
[dbSetIndex( cIndex2 )]
xcAlias
] [EXCLUSIVE|SHARED] [NEW] [
READONLY
cDatabase,
[cAlias], [lShared], [lReadOnly]
)
...
371.17 nB command substitution functions
Inside nB there are many functions made only in substitution to other Clipper commands.
GET
@ nTop , nLeft GET Var
PICTURE cGetPicture
COLOR cColorString
WHEN lPreExpression
VALID lPostExpression
[
[
[
[
]
]
]
]
Get( @aGetList ,
nTop , nLeft ,
{ |x| iif( pcount() > 0, Var := x, Var ) }
cGetPicture , cColorString ,
bPreExpression , bValid
)
[
[
[
] [ ]
] [
] [
]
]
is the get list array that will be increased with this get().
aGetList
SAY
@ nTop , nLeft SAY exp
PICTURE cSayPicture
COLOR cColorString
[
Say( nTop , nLeft ,
]
cVar , [cSayPicture ], [cColorString ]
APPEND FROM
APPEND FROM xcFile
FIELDS idField_list
scope
WHILE lCondition
FOR lCondition
VIA xcDriver
[
[
[
[
[
]
]
]
]
]
dbApp( cFileName , [acFields],
[bForCondition ], [bWhileCondition ],
[nNextRecords ],
[nRecord],
[lRest],
[cDriver] )
APPEND FROM xcFile
FIELDS idField_list
scope
WHILE lCondition
FOR lCondition
DELIMITED xcDelimiter
[
[
[
[
]
]
]
]
)
4270
[
] [
]
] [ ]
]
dbDelim( .f., cFileName , cDelimiter , acFields ,
)
[
[
] [
] [
APPEND FROM xcFile
FIELDS idField_list
scope
WHILE lCondition
FOR lCondition
SDF
[
[
[
[
]
]
]
]
[
]
dbSDF( .f., cFileName , acFields ,
[
[
] [
] [
]
] [
]
)
CONTINUE
CONTINUE
dbContinue()
COPY
COPY FILE xcSourceFile TO xcTargetFile |xcDevice
CopyFile( cSourceFile , cTargetFile |cDevice )
[
]
COPY STRUCTURE FIELDS idField_list
TO xcDatabase
dbCopyStruct( cDatabase,
[acFields]
)
COPY STRUCTURE EXTENDED
TO xcExtendedDatabase
dbCopyXStruct( cExtendedDatabase )
COPY TO xcFile
FIELDS idField_list
scope
WHILE lCondition
FOR lCondition
VIA xcDriver
[
[
[
[
[
]
]
]
]
]
dbCopy( cFileName , [acFields],
[nNextRecords ],
[nRecord],
[lRest],
[cDriver] )
COPY TO xcFile
FIELDS idField_list
scope
WHILE lCondition
FOR lCondition
DELIMITED xcDelimiter
[
[
[
[
]
]
]
]
[
] [
]
] [ ]
]
dbDelim( .t., cFileName , cDelimiter , acFields ,
)
[
[
] [
] [
COPY TO xcFile
FIELDS idField_list
scope
WHILE lCondition
FOR lCondition
SDF
[
[
[
[
]
]
]
]
[
]
dbSDF( .t., cFileName , acFields ,
[
[
] [
] [
]
] [
]
)
4271
CREATE
CREATE xcDatabase
FROM xcExtendedDatabase
NEW
ALIAS cAlias
VIA cDriver
[ ]
[
[
]
]
dbOldCreate( cDatabase, cExtendedDatabase ,
cDriver , lNew , cAlias
)
[
] [
] [
]
JOIN
JOIN WITH xcAlias TO xcDatabase
FOR lCondition
FIELDS idField_list
[
][
]
dbJoin( cAlias , cDatabase,
acFields , bForCondition
[
] [
]
)
KEYBOARD
KEYBOARD cString
Keyboard(
[cString]
) ⇒ NIL
LABEL FORM
LABEL FORM xcLabel
TO PRINTER
TO FILE xcFile
NOCONSOLE
scope
WHILE lCondition
FOR lCondition
SAMPLE
[
[
[
[
[
[
[
]
]
]
]
]
]
]
[
] [
] [
] [ ]
] [
] [ ] [
dbLabelForm( cLabel , lToPrinter , cFile ,
lNoConsole , bForCondition , bWhileCondition
nNextRecords , nRecord , lRest , lSample
[
[
LIST
LIST exp_list
TO PRINTER
TO FILE xcFile
scope
WHILE lCondition
FOR lCondition
OFF
[
]
[
]
[ ]
[
]
[
]
[ ]
dbList( [lToDisplay], abListColumns ,
[lAll],
[nNextRecords ], [nRecord], [lRest],
[lToPrinter], [cFileName ] )
LOCATE
[scope] FOR lCondition
[WHILE lCondition]
dbLocate( [bForCondition ], [bWhileCondition ],
[nNextRecords ], [nRecord], [lRest] )
LOCATE
PACK
PACK
dbPack()
],
])
4272
PUBLIC
PUBLIC idMemvar
MemPublic( cMemvarName |acMemvarNames )
QUIT
QUIT
Quit()
RELEASE
RELEASE idMemvar
MemRelease( cMemvarName |acMemvarNames )
REPORT FORM
REPORT FORM xcReport
TO PRINTER
TO FILE xcFile
NOCONSOLE
scope
WHILE lCondition
FOR lCondition
PLAIN | HEADING cHeading
NOEJECT
SUMMARY
[
[
[
[
[
[
[
[
]
]
]
]
]
]
][
]
]
RF( cForm ,
nNext , nRecord , lRest , lPlain ,
cbHeading , lBeforeEject , lSummary ,
lDate , acExtra
) ⇒ NIL
[
[
[
[
] [
]
] [
] [ ] [
] [
] [
] [
]
]
]
RESTORE FROM
[ADDITIVE]
cMemFileName , [lAdditive]
RESTORE FROM xcMemFile
MemRestore(
)
RUN
RUN xcCommandLine
Run( cCommand )
SAVE TO
SAVE TO xcMemFile
ALL LIKE|EXCEPT skeleton
[
MemSave(
[
]]
cMemFileName , [cSkeleton ], [lLike ]
SET FUNCTION
SET FUNCTION nFunctionKey TO cString
SetFunction( nFunctionKey , cString )
SORT
SORT TO xcDatabase
ON idField1 / A|D
, idField2 / A|D
scope
WHILE lCondition
FOR lCondition
[
[
[
[
[ [ ][C]]
[ [ ][C]] ...]
]
]
]
dbSort( cDatabase, [acFields],
[nNextRecords ], [nRecord], [lRest]
)
)
4273
TOTAL
TOTAL ON expKey
FIELDS idField_list
scope
WHILE lCondition
FOR lCondition
[
[
[
[
]
TO xcDatabase
]
]
]
[
dbTotal( cDatabase, bKey, acFields ,
nNextRecords , nRecord
, lRest
[
[
] [
] [
]
]] [ ]
)
UPDATE
UPDATE FROM xcAlias
ON expKey RANDOM
REPLACE idField1 WITH exp
, idField2 WITH exp ...
[
]
[
dbUpdate( cAlias , bKey,
]
[lRandom ], [bReplacement ]
)
Example:
dbUpdate( "INVOICE", {|| LAST}, .T.,;
{|| FIELD->TOTAL1 := INVOICE->SUM1,;
FIELD->TOTAL2 := INVOICE->SUM2 } )
ZAP
ZAP
dbZap()
371.18 RPT: the nB print function
The function RPT() helps to print ASCII file containing Memvars, Fields and print commands.
RPT() is accessible from the DOC() menu.
371.18.1 Memvars and fields
As usual with standard word processors, variables are written delimited with "<" (Alt+174) and
">" (Alt+175).
Inside these delimiters can find place character Memvars, character Fields and functions giving
a character result.
The RPT() function generates a public variable n_Lines that contains the available lines inside
the actual sheet. Every time a line is written, this value is reduced, until a new page is reached and
then it will start again from the maximum value. It is useful to read this variable to determinate
if there is enough space or it is better to change page.
371.18.2 Commands
The function RPT() recognise some print commands. These commands starts with the asterisk
(*) symbol. This means that "*" is a print command prefix.
It follows the command syntax.
*COMMAND
*COMMAND
cStatement
cStatement
...
*END
4274
The lines contained inside *COMMAND - *END are executed with the nB macro interpreter.
*DBSKIP
*DBSKIP
[nSkip ]
It Executes a dbskip() on the active alias.
*FOOT
*FOOT
cFooter
cFooter
...
*END
The lines contained inside *FOOT - *END are printed each time at the bottom of pages.
*HEAD
*HEAD
cHeader
cHeader
...
*END
The lines contained inside *HEAD - *END are printed each time at the top of pages.
*IF
*IF lCondition
...
...
*END
If the condition lCondition is true, the lines contained inside *IF - *END are printed.
*INSERT
*INSERT cFileName
Includes the text contained into the file cFileName .
*LEFT
*LEFT nLeftBorder
The nLeftBorder is the number of column to be left blank as a left border.
*LPP
*LPP nLinesPerPage
It determinates the page length expressed in lines. After printing the nLinesPerPage th line,
a form feed is sent.
*NEED
*NEED nLinesNeeded
If the available lines are less then nLinesNeeded , the follwing text will be printed on the
next page.
*PA
*PA
Jumps to a new page.
*REM
*REM
| *COMMENT [comment_line ]
It adds a comment that will not be printed.
4275
*WHILE
*WHILE lCondition
...
...
*END
The lines contained inside *WHILE - *END are printed as long as lCondition is true.
371.18.3 Examples
It follows some example of text to be printed with the RPT() function. Example’s lines are numbered. Line numbers must not be part of a real RPT text files.
PAGE DEFINITION
Margins are defined with *HEAD, *FOOT and *LEFT commands. In the following example is defined:
Top
2 lines;
Bottom
2 lines;
Left
10 characters.
The right margin is not defined as it depends on the lines length that will be printed.
The only considered page dimension is the height, *LPP (lines per page):
Page height
66 lines.
Here starts the example:
001
002
003
004
005
006
007
008
009
010
011
012
...
*lpp 66
*head
*end
*foot
*end
*left 10
... text text text
... test text text
At line 001 is defined the page height in lines. At line 002 is defined the header; it contains
two empty lines (003 and 004) which will be printed at the top of every page. At line 006
starts the footer definition that contains two empty lines (007 and 008) that will be printed
at the end of every page. At line 010 is defined the space on the left that will be added to
every line printed. From line 011 starts the normal text.
HEADER AND FOOTER
The commands *HEAD and *FOOT are used to define the top and bottom border if they
contains empty lines, it these lines are not empty, they became real head and foot.
The dimensions are as it follows:
Top
6 lines (should be one inch);
Bottom
6 lines;
Left
10 characters (should be an inch).
Page height
66 lines (should be 11 inch).
At position 0.5 in (after 3 lines) a one line header appears.
4276
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
...
*lpp 66
*head
------------------- MYFILE.TXT -------------------
*end
*foot
*end
*left 10
... text text text
... test text text
At line 006 (the fourth header line) a text appears. It will be printed on every page at the
absolute fourth page line.
CODE INSERTION
Pieces of code can be inserted inside *COMMAND - *END. It can be useful to make
complicated reports.
The following example declares a public variable used to number pages.
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
...
*command
mempublic("PageNo")
PageNo := 0
*end
*lpp 66
*head
*command
PageNo := PageNo +1
*end
*end
*foot
Page <PageNo>
*end
*left 10
... text text text
... test text text
At line 001 starts a *COMMAND definition: lines 002 and 003 will be interpreted from the
function EX(), the nB interpreter. These lines define a public variable and initialize it at 0.
This variable will be use to count pages.
At line 007, inside the header (nested), start another *COMMAND definition that contains
an increment for the "PageNo" variable. As the header is read and "executed" for every new
page, and that before the footer, the variable "PageNo" will contain the right page number.
At line 015, inside the footer, a reference to "PageNo" appears. Here will be printed the
page number.
A more complicated example can be found in ‘ADDRESS.TXT’ the RPT text file used for
the ADDRESS.& macro examples.
4277
371.19 How can I...
nB is a little bit complicated as it may do many things. Here are some examples.
Create a UDF function
UDF means User Defined Function. Inside nB there isn’t the possibility to create functions,
but there is an alternative: code blocks.
Create a big code block
A code block cannot be longer than 254 characters, as any other instruction inside nB.
So, there is no way to make a bigger code block, but a code block can call another code
block, and so on. For example:
mempublic( { "first", "second", "third" } )
first := {|| eval( second, "hello" ) }
second := {|x| eval( third, x ) }
third := {|x| alertbox( x ) }
eval( first )
This stupid example simply will show the alert box containing the word "hello".
371.20 The source files
The nB source is composed of four files:
‘NB.PRG’
‘REQUEST.PRG’
‘STANDARD.PRG’
‘EXTRA.PRG’
The main source file containing essentially the nB menu.
Contains a link to all Clipper standard functions.
Contains the most important standard functions.
Contains some extra function not absolutely necessary during
macro execution.
The file ‘REQUEST.PRG’ source file generates some warnings because not all functions listed
there are directly called form nB. Don’t worry about that warning message.
Different ‘.RMK’ (rmake) files are included to compile nB differently, including/excluding some
program parts, for example to obtain a runtime executor.
Appunti di informatica libera 2003.01.01 --- Copyright © 2000-2003 Daniele Giacomini -- daniele @ swlibero.org
4278
Parte lxxviii
Sistemi operativi speciali
372 LeeOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4280
4279
Capitolo
372
LeeOS
LeeOS 1 è un sistema operativo specifico per i86 realizzato in modo da utilizzare il minimo di
risorse necessario.
I file binari che compongono il sistema, ovvero il settore di avvio, un programma di inizializzazione, il kernel e la shell, vanno collocati in un dischetto in settori specifici. Per la realizzazione
di un dischetto di avvio corretto viene fornito un programma Dos, ‘COPYBOOT.EXE’, che richiede
l’indicazione del nome del file da copiare e del settore iniziale in cui collocarlo nel dischetto. In
pratica, per la versione 0.0.2 si interviene con i comandi seguenti:
C:>COPYBOOT BOOT.BIN 0
C:>COPYBOOT INIT.BIN 1
C:>COPYBOOT KERNEL.BIN 2
C:>COPYBOOT SHELL.BIN 4
Volendo usare ‘dd’ in un sistema Unix, i comandi dovrebbero essere i seguenti, tenendo conto
che ‘/dev/fd0’ è inteso essere il file di dispositivo dell’unità a dischetti, come avviene con
GNU/Linux:
# dd if=boot.bin of=/dev/fd0 obs=512 seek=0
# dd if=init.bin of=/dev/fd0 obs=512 seek=1
# dd if=kernel.bin of=/dev/fd0 obs=512 seek=2
# dd if=shell.bin of=/dev/fd0 obs=512 seek=4
Il dischetto che si ottiene così può essere avviato anche all’interno di DOSEMU:
# dos -A
Si ottiene un invito come quello seguente:
Welcome to LeeOS!
Guest / >
La shell a disposizione offre qualche comando; in particolare consente l’uso del comando ‘help’:
Guest / > help[ Invio ]
LeeOS version 0.0.2 Copyright (c) 2001 by Robert Lee
The following commands are available:
+
+
+
+
+
+
+
+
help
status
login
run
type
cls
reset
shutdown
1
Display this message
Display session information
Change user
Execute machine code on a specified sector
Display the contents of a specified sector
Clear the screen
Restart the system
Prepare system for reset
LeeOS licenza quasi identica alla Artistic
4280
LeeOS
4281
Nel momento in cui viene scritto questo capitolo introduttivo al sistema LeeOS, il lavoro di
sviluppo è appena iniziato e non ci sono applicativi che possano essere utilizzati con tale sistema.
4282
LeeOS
Parte lxxix
Braille
373 Introduzione al sistema braille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4284
373.1 Origini e caratteristiche del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4284
373.2 Codifica semplificata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4285
373.3 Braille a otto punti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4286
373.4 Tabelle di conversione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4286
373.5 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4288
374 Sistemi di interazione per non vedenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4289
374.1 Lettura di ciò che appare sullo schermo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4289
374.2 Terminali braille . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4290
374.3 Brltty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4291
374.4 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4292
4283
Capitolo
373
Introduzione al sistema braille
Lo scopo di questo capitolo è quello di descrivere brevemente il codice usato dal sistema braille,
in modo di facilitare la comprensione del funzionamento di un terminale per non vedenti. Ciò
potrebbe servire per verificare l’installazione e la configurazione corretta di un dispositivo del
genere.
373.1 Origini e caratteristiche del sistema
Il sistema di scrittura per non vedenti è stato inventato da Louis Braille nel 1829, da cui viene
il nome. Luis Braille era francese e in questo senso vanno viste le scelte che possono sembrare
insolite, per chi è abituato a convenzioni derivanti dalla lingua inglese.
Il sistema codifica 63 simboli rappresentati ognuno da una cella in cui possono essere collocati
un massimo di sei punti in rilievo:
.----.
|* *|
|* *|
|* *|
‘----’
Tanto per fare un esempio, se si possono immaginare gli asterischi della figura seguente come
altrettanti punti in rilievo, la parola «ciao!» si può rappresentare in questo modo:
* *
*
*
*
*
*
*
* *
*
Il sistema braille è fatto fondamentalmente per una scrittura manuale, che avviene attraverso
l’uso di una tavoletta speciale, come si può vedere nelle figure 373.3 e 373.4.
Figura 373.3. Tavoletta di scrittura braille normale.
4284
4285
La scrittura avviene su un foglio di cartoncino bloccato sulla tavoletta, con l’aiuto di un punteruolo, guidato dalle feritoie poste su un regolo mobile (nel caso della tavoletta tascabile, il regolo
è fisso). Dal momento che la scrittura avviene attraverso l’incisione del cartoncino, la lettura tattile, in rilievo, potrà avvenire solo sull’altro lato; pertanto, per quanto riguarda le lingue latine, la
scrittura avviene da destra verso sinistra e la lettura da sinistra a destra.
Figura 373.4. Tavoletta di scrittura braille tascabile. La fase si scrittura avviene incidendo il cartoncino. In questo caso, non si vede la fila superiore, perché rimane coperta
dall’ombra.
Figura 373.5. Testo inciso da destra verso sinistra.
Figura 373.6. Testo in rilievo da sinistra verso destra.
Il braille standard è composto da celle con un massimo di sei punti in rilievo, per un massimo
di 26-1 segni, più lo spazio; tuttavia, possono esistere anche dispositivi braille predisposti per
un massimo di otto punti in rilievo.
373.2 Codifica semplificata
La disposizione classica della codifica del braille è sintetizzata dalle figure 373.9 e 373.10. Chi
volesse studiare ed esercitarsi con il braille, farebbe bene a copiare le due figure in modo da
mettere a sinistra quella dei segni in scrittura e a destra quella dei segni in lettura.
Come si può comprendere a livello intuitivo, i 63 simboli non consentono di distinguere le lettere minuscole da quelle maiuscole; in generale si tratta sempre solo di lettere minuscole che
diventano maiuscole se precedute dal segno relativo. Per esempio, «Daniele» si scrive così:
*
*
* * *
*
* *
* *
*
* *
* *
*
*
*
*
4286
Nello stesso modo, come si vede, non sono previsti i numeri. Questi si ottengono indicando il
segno di numero davanti alle prime 10 lettere alfabetiche. Per esempio, 123 si indica così:
*
*
* *
*
*
*
* *
Pertanto, a differenza delle maiuscole, il segno di numero vale per tutta la sequenza di simboli
successiva.
Esistono naturalmente altri dettagli molto importanti per chi deve usare il braille, che però qui
non vengono descritti. Purtroppo, i segni a disposizione sono molto pochi e di conseguenza, tutto
quanto ha sempre un valore relativo al contesto.
373.3 Braille a otto punti
La codifica a otto punti consente di utilizzare una sola cella per indicare una lettera maiuscola o
un numero. Ciò diventa particolarmente importante in un terminale braille, in cui è bene che si
possa mantenere una corrispondenza tra celle e caratteri.
373.4 Tabelle di conversione
L’abbinamento del braille all’informatica, impone l’introduzione di tabelle di conversione dalla
codifica dei caratteri al braille stesso. In pratica, in base alla nazionalità, si utilizza una codifica
particolare; oltre a questo, deve essere definito un abbinamento tra codice binario (ASCII, ISO
8859-n , ecc.) e rappresentazione braille. Quando si utilizza un terminale braille o un sistema di
stampa braille, occorre stabilire anche questo tipo di conversione.
4287
Figura 373.9. La codifica braille per la scrittura da destra verso sinistra, secondo
l’ordine classico.
j
*
*
.
.
*
.
*
.
.
i
.
*
.
.
*
.
h
*
*
.
*
*
.
g
*
*
.
*
.
.
.
*
*
*
.
.
s
.
*
*
.
*
.
r
*
*
*
*
*
.
q
*
*
*
*
.
.
.
*
*
*
.
*
è
.
*
*
.
*
*
à
*
*
*
*
*
*
é
*
*
*
*
.
*
.
*
.
*
.
*
æ
.
*
.
.
*
*
ü
*
*
.
*
*
*
ï
*
*
.
*
.
*
.
.
*
.
*
.
*
.
.
*
.
.
*
»
.
*
*
.
*
*
t
*
*
.
ù
*
*
*
w
*
*
*
«
.
*
*
numero
* .
* .
* *
.
.
*
.
.
.
.
*
*
.
.
.
f
.
*
.
e
*
.
.
*
*
.
d
*
.
.
*
.
.
*
*
*
.
*
.
o
*
.
*
*
*
.
n
*
.
*
*
.
.
*
*
*
.
*
*
z
*
.
*
*
*
*
y
*
.
*
*
.
*
*
*
.
.
*
*
û
*
.
.
*
*
*
ô
*
.
.
*
.
*
.
*
*
.
.
*
?
.
*
.
.
*
*
.
.
*
.
.
*
.
p
ç
ë
()
!
.
*
*
ò
*
.
*
*
*
.
.
.
*
maiuscole
* .
. .
* .
.
*
.
verso
* .
* .
. *
.
*
.
.
.
.
ì
*
.
*
*
.
.
corsivo
* .
* .
* .
c
*
.
.
.
.
.
b
*
*
.
.
.
.
a
*
.
.
*
.
*
.
.
.
l
*
*
*
.
.
.
k
*
.
*
*
.
*
.
.
*
v
*
*
*
.
.
*
u
*
.
*
*
.
.
.
.
*
ê
*
*
.
.
.
*
â
*
.
.
.
*
.
.
.
.
;
.
*
*
.
.
.
,
.
*
.
m
x
î
:
lineetta
. .
. .
* *
*
*
.
.
.
.
apostrofo
. .
. .
. *
*
.
.
.
.
.
4288
Figura 373.10. La codifica braille per la lettura da sinistra verso destra, secondo
l’ordine classico.
a
*
.
.
b
.
.
.
*
*
.
.
.
.
*
*
*
.
.
*
*
*
*
.
.
*
*
*
.
.
.
.
.
*
*
k
*
.
*
*
.
*
.
.
*
*
.
*
.
.
*
*
.
.
.
.
.
.
*
.
d
*
.
.
*
.
.
*
.
.
*
.
*
*
.
*
*
.
*
*
.
*
*
.
.
.
*
.
.
*
.
m
*
*
.
*
.
*
*
*
*
*
.
*
*
*
*
*
.
.
:
.
*
*
.
*
.
.
.
.
.
.
.
*
*
.
*
*
.
.
*
.
*
*
*
.
*
*
*
*
*
.
*
*
*
*
.
.
.
*
.
*
*
*
.
.
*
*
*
*
.
*
*
*
*
*
.
*
*
*
.
.
*
.
.
*
*
.
.
.
.
*
.
*
*
.
*
*
.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
.
.
*
*
.
*
*
i
.
*
.
.
*
.
.
*
.
.
*
*
.
*
*
.
*
*
.
*
*
.
*
.
.
.
*
.
.
*
r
é
maiuscole
. *
. .
. *
*
.
.
.
*
*
*
*
.
*
.
*
.
*
*
*
.
*
.
*
.
.
*
.
.
.
*
.
*
*
.
.
.
.
.
*
t
*
*
.
ù
æ
«
ò
. *
. .
* *
.
*
.
è
ü
()
j
*
.
.
s
à
ï
!
verso
. *
. *
* .
h
*
*
.
q
ë
?
corsivo
. *
. *
. *
*
*
.
ç
û
ì
* *
. .
. *
g
*
.
.
p
z
.
lineetta
. .
. .
* *
f
.
*
.
o
ô
apostrofo
. .
. .
* .
*
.
.
*
.
.
y
î
;
e
*
*
.
n
x
ê
,
.
*
.
.
.
.
v
â
*
.
.
*
.
.
l
u
*
.
*
c
.
.
.
*
*
*
w
*
*
*
*
»
numero
. *
. *
* *
.
.
.
.
*
*
373.5 Riferimenti
• Dottless braille
<http://www.dotlessbraille.org/>
• A (slightly) different introduction to braille
<http://www.dotlessbraille.org/AboutBraille.htm>
Capitolo
374
Sistemi di interazione per non vedenti
I sistemi standard di interazione per non vedenti con un elaboratore sono di due tipi, che si
integrano convenientemente assieme: il terminale braille e la lettura automatica di ciò che appare
sullo schermo. Il terminale braille è un’unità che si collega generalmente a una porta seriale o
parallela e richiede la presenza di un programma in grado di leggere ciò che appare sullo schermo
normale; il sistema di lettura automatica richiede naturalmente un programma simile.
Un sistema di lettura automatico è apparentemente un problema semplice da risolvere; in pratica
le cose non sono così, perché deve anche essere in grado di individuare la struttura del testo (si
pensi a un’organizzazione in più colonne). Il sistema che sembra essere più efficace per la lettura
sonora del testo è Emacspeach, che comunque qui non viene descritto. Si vedano eventualmente
i riferimenti bibliografici alla fine del capitolo.
374.1 Lettura di ciò che appare sullo schermo
Qualunque sistema di lettura per non vedenti (braille o audio), deve avere un modo per accedere
a ciò che appare sullo schermo. Esistono evidentemente due modi: ciò che appare sullo schermo
è controllato direttamente dal programma di lettura, oppure questo programma deve interagire
con il sistema operativo per ottenere una copia dello schermo.
Un programma che controlla ciò che si deve leggere potrebbe essere una shell, oppure una sorta
di navigatore ipertestuale, che eventualmente incorpori anche delle funzionalità per la creazione
e la modifica dei documenti (dovrebbe essere questo il caso di Emacspeach).
Nel caso di GNU/Linux si accede a una copia di ciò che appare sullo schermo della console
attiva attraverso il file di dispositivo ‘/dev/vcsa’ o ‘/dev/vcsa0’. In particolare questi file di
dispositivo consentono di ottenere informazioni anche sugli attributi del testo, cosa che permette
di localizzare il cursore, per esempio; esistono infatti anche i file di dispositivo ‘/dev/vcs*’
che consentono di ottenere una pura copia testuale delle console virtuali.
Questi file di dispositivo sono normalmente inaccessibili a utenti diversi dall’amministratore;
pertanto, per consentire una lettura a programmi con privilegi limitati, occorre intervenire nei
permessi. Supponendo di dover creare da zero il file di dispositivo ‘/dev/vcsa0’, probabilmente
si dovrebbe agire come segue:
# mknod /dev/vcsa0 c 7 128[ Invio ]
# chown root.tty /dev/vcsa0[ Invio ]
# chmod 660 /dev/vcsa0[ Invio ]
In pratica, si arriva alla fine a dare i permessi di lettura e scrittura anche al gruppo, supponendo
che il programma che deve utilizzarlo funzioni, in questo caso, con i privilegi del gruppo ‘tty’
(SGID-‘tty’). Ciò consente di mantenere un minimo di riservatezza, nonostante il problema
contingente da risolvere.
Volendo verificare che il file di dispositivo ‘/dev/vcsa0’ consente di accedere al contenuto
dello schermo della console virtuale attuale, si può inviarne una copia in una console inattiva o
comunque non utilizzata. Per esempio:
# cat /dev/vcsa0 > /dev/tty12[ Invio ]
Manda una copia alla 12-esima console virtuale e si può verificare facilmente con la
combinazione di tasti [ Alt+F12 ].
4289
4290
374.2 Terminali braille
Il terminale braille è solitamente un componente da collocare al di sotto della tastiera normale,
attraverso il quale è possibile leggere una riga di testo, senza allontanare troppo le dita dalla
tastiera stessa.
Vicino alla barra contenente le celle braille, devono essere disponibili alcuni tasti per il controllo
del terminale stesso, per poter navigare sulla superficie di quello che appare sullo schermo. Infatti,
di solito di dispone di una sola riga di celle braille, ma anche se potessero essere disponibili più di
una, non sarebbero mai quante le righe che si vedono su uno schermo normale; inoltre, anche la
quantità di celle è limitata, per cui diventa necessario poter spostare la «visualizzazione» braille
anche in orizzontale.
Figura 374.1. Collocazione tipica di un terminale braille, sotto la tastiera o sotto un
elaboratore portatile.
La figura 374.2 mostra in particolare un dettaglio delle celle di un terminale braille a otto punti.
Figura 374.2. Dettaglio delle celle di un terminale braille.
4291
374.3 Brltty
Brltty 1 è un programma in grado di comunicare con un terminale braille, allo scopo di inviargli
ciò che accade sullo schermo della console virtuale attiva di un sistema GNU/Linux.
Il funzionamento del programma è relativamente semplice: si tratta di un demone, ‘brltty’, da
avviare e fermare automaticamente attraverso la procedura di inizializzazione del sistema, che
comunica con il terminale braille seguendo la configurazione relativa al terminale stesso e la
configurazione della conversione braille.
In pratica, Brltty deve conoscere il tipo di terminale braille utilizzato e deve disporre di una tabella
di conversione adatta per quanto riguarda la codifica usata e l’alfabeto braille dell’utilizzatore.
374.3.1 Configurazione
Brltty è accompagnato da una serie di file di libreria, per l’adattamento alle caratteristiche del
terminale braille e per la conversione finale della codifica in braille. Questi file dovrebbero essere
collocati nella directory ‘/etc/brltty/’.
Il file di configurazione in cui occorre intervenire dovrebbe essere ‘/etc/brltty.conf’, il cui
contenuto potrebbe apparire come nell’esempio seguente:
braille-device /dev/ttyS0
braille-driver ec
dot-translation text.us.tbl
Si comprende intuitivamente il significato delle direttive: il terminale viene connesso alla prima
porta seriale, corrispondente al file di dispositivo ‘/dev/ttyS0’; il terminale braille viene gestito attraverso un protocollo definito dalla sigla ‘ec’; la trasformazione della codifica in braille
avviene secondo il modello denominato ‘text.us.tbl’, che in pratica è un file contenuto nella
directory ‘/etc/brltty/’, facente riferimento a un adattamento per la lingua inglese.
Tabella 374.1. Sigle attraverso le quali si abbinano le librerie di controllo del terminale
braille.
Sigla
al
b1
b4
cb
ec
eu
md
pm
ts
va
Terminale corrispondente
Alva (ABT3xx/Delphi)
BrailleLite 18
BrailleLite 40
Tieman CombiBraille
EcoBraille
EuroBraille
MDV braille
Papenmeier
TSI (PowerBraille/Navigator)
BAUM Vario
Brltty è anche in grado di gestire terminali parlanti. Eventualmente, si può usare la direttiva
‘speech-driver’ per il controllo della sintesi vocale. Di solito, la funzionalità è disabilitata,
con la direttiva seguente:
speech-driver no
1
Brltty GNU GPL
4292
Tabella 374.2. Sigle relative alla gestione della sintesi vocale.
Sigla
no
al
bl
cb
fv
gs
tv
Sintesi vocale
No Speech
Alva (Delphi)
BrailleLite
Tieman CombiBraille
Festival Text to Speech Package
Generic Say (invia allo standard input di ‘/usr/local/bin/say’)
Televox Speech Interface
374.3.2 Accesso alla copia della console virtuale corrente
Come già spiegato in precedenza, anche Brltty deve poter accedere a una copia della console
virtuale corrente. Ciò avviene precisamente attraverso il file di dispositivo ‘/dev/vcsa0’, che in
alcuni sistemi GNU/Linux potrebbe anche essere assente, perché equivalente a ‘/dev/vcsa’. Si
riepilogano nuovamente i passi necessari a creare il file e ad attribuirgli i permessi necessari per
il funzionamento corretto con Brltty.
# mknod /dev/vcsa0 c 7 128[ Invio ]
# chown root.root /dev/vcsa0[ Invio ]
# chmod 600 /dev/vcsa0[ Invio ]
In questo caso, si presume che il demone ‘brltty’ sia avviato attraverso la procedura di inizializzazione del sistema, in modo tale da funzionare con tutti i privilegi dell’utente ‘root’.
Diversamente, occorre cambiare strategia per quanto riguarda i permessi e la proprietà del file di
dispositivo.
374.4 Riferimenti
• BRLTTY - official home
<http://dave.mielke.cc/brltty/>
• BRLSPEAK: a braille and speech mini-distribution of GNU/Linux
<http://www.audiobraille.org/blinux/brlspeak.html>
• Blind + Linux = BLINUX
<http://leb.net/blinux/>
Parte lxxx
Aspetti umani
375 Manifesto GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4294
376 Il progetto GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4302
376.1 La prima comunità di condivisione del software . . . . . . . . . . . . . . . . . . . . . . . . . . 4302
376.2 La comunità si dissolve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4302
376.3 Una difficile scelta morale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4304
376.4 "Free" come libero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4305
376.5 Software GNU e il sistema GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4305
376.6 L’inizio del progetto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4306
376.7 I primi passi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4306
376.8 GNU Emacs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4306
376.9 Un programma è libero per tutti? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4307
376.10 Il permesso d’autore (copyleft) e la GNU GPL . . . . . . . . . . . . . . . . . . . . . . . . . . 4307
376.11 La Free Software Foundation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4308
376.12 Il supporto per il software libero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4309
376.13 Obiettivi tecnici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4309
376.14 Donazioni di computer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4309
376.15 L’elenco dei compiti GNU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4310
376.16 La licenza GNU per le librerie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4310
376.17 Togliersi il prurito? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4311
376.18 Sviluppi inattesi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4311
376.19 GNU-Hurd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4312
376.20 Alix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4312
376.21 Linux e GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4312
376.22 Le sfide che ci aspettano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4313
376.23 Hardware segreto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4313
376.24 Librerie non libere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4313
376.25 Brevetti sul software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4314
376.26 Documentazione libera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4314
376.27 Dobbiamo parlare di libertà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4315
376.28 "Open Source" . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4316
376.29 Prova! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4316
377 Proprietà del software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4317
377.1 Dal copyright al brevetto e conseguenze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4317
377.2 Problemi legati al brevetto sul software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4319
377.3 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4320
378 L’ipotesi del futuro, nel bene e nel male . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4321
378.1 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4322
Indice analitico del volume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4323
4293
Capitolo
375
Manifesto GNU
non modificabile
Testo originale: <http://www.fsf.org/gnu/manifesto.html>
Traduzione originale: <http://www.fsf.org/gnu/manifesto.it.html>
Copyright (C) 1985, 1993 Free Software Foundation, Inc.
Chiunque è autorizzato a fare o distribuire copie letterali di questo documento, con qualsiasi
mezzo, a condizione che siano riprodotte la nota sul copyright e la nota di autorizzazione, e che
il distributore conceda al destinatario l’autorizzazione di ridistribuirlo a sua volta alle condizioni
permesse da questa nota.
Non sono consentite versioni modificate.
Il Manifesto GNU
Il Manifesto GNU (che appare sotto) venne scritto da Richard Stallman all’inizio
del progetto GNU, per sollecitare sostegno e partecipazione. Durante i primi anni il
manifesto venne lievemente aggiornato per tener conto degli sviluppi, ma adesso la
scelta migliore sembra essere quella di lasciarlo immutato nella forma in cui molti lo
hanno visto.
Da allora abbiamo preso atto di alcuni fraintendimenti che si potrebbero evitare con
una diversa scelta di termini. Le note in calce aggiunte nel 1993 aiutano a chiarire
questi punti.
Per informazioni aggiornate sulla disponibilità del software GNU, consultate quelle
disponibili sul nostro server web, in particolare il nostro elenco del software.
Cos’è GNU? Gnu Non è Unix!
GNU, che sta per "Gnu’s Not Unix" (Gnu Non è Unix), è il nome del sistema software completo
e Unix-compatibile che sto scrivendo per distribuirlo liberamente a chiunque lo possa utilizzare.1
Molti altri volontari mi stanno aiutando. Abbiamo gran necessità di contributi in tempo, denaro,
programmi e macchine.
Fino ad ora abbiamo un editor Emacs fornito di Lisp per espanderne i comandi, un debugger simbolico, un generatore di parser compatibile con yacc, un linker e circa 35 utility. È quasi pronta
una shell (interprete di comandi). Un nuovo compilatore C portabile e ottimizzante ha compilato
se stesso e potrebbe essere pubblicato quest’anno. Esiste un inizio di kernel, ma mancano molte
delle caratteristiche necessarie per emulare Unix. Una volta terminati il kernel e il compilatore
sarà possibile distribuire un sistema GNU utilizzabile per lo sviluppo di programmi. Useremo
TeX come formattatore di testi, ma lavoriamo anche su un nroff. Useremo inoltre il sistema a
1
La scelta delle parole è stata poco accurata. L’intenzione era che nessuno dovesse pagare per il *permesso* di usare
il sistema GNU. Ma le parole non lo esprimono chiaramente, e la gente le interpreta spesso come asserzione che GNU
debba sempre essere distribuito in forma gratuita o a basso prezzo. Non è mai stato questo l’intento; più oltre il manifesto
parla della possibile esistenza di aziende che forniscano il servizio di distribuzione a scopo di lucro. Di conseguenza ho
imparato a distinguere tra "free" nel senso di libero e "free" nel senso di gratuito. Il software libero è il software che gli
utenti sono liberi di distribuire e modificare. Alcuni lo avranno gratuitamente, altri dovranno pagare per ottenere le loro
copie, e se dei finanziamenti aiutano a migliorare il software tanto meglio. La cosa importante è che chiunque ne abbia
una copia sia libero di cooperare con altri nell’usarlo.
4294
Manifesto GNU
4295
finestre portabile libero X. Dopo di che aggiungeremo un Common Lisp portabile, il gioco Empire, un foglio elettronico e centinaia di altre cose, oltre alla documentazione in linea. Speriamo
di fornire, col tempo, tutte le cose utili che normalmente si trovano in un sistema Unix, ed anche
di più.
GNU sarà in grado di far girare programmi Unix, ma non sarà identico a Unix. Apporteremo tutti
i miglioramenti che sarà ragionevole fare basandoci sull’esperienza maturata con altri sistemi
operativi. In particolare abbiamo in programma nomi più lunghi per i file, numeri di versione per
i file, un filesystem a prova di crash, forse completamento automatico dei nomi dei file, supporto
indipendente dal terminale per la visualizzazione e forse col tempo un sistema a finestre basato
sul Lisp, attraverso il quale più programmi Lisp e normali programmi Unix siano in grado di
condividere lo schermo. Sia C che Lisp saranno linguaggi per la programmazione di sistema. Per
le comunicazioni vedremo di supportare UUCP, Chaosnet del MIT ed i protocolli di Internet.
GNU è inizialmente orientato alle macchine della classe 68000/16000 con memoria virtuale,
perché sono quelle su cui è più facile farlo girare. Lasceremo agli interessati il lavoro necessario
a farlo girare su macchine più piccole.
Vi preghiamo, per evitare confusioni, di pronunciare la ’G’ nella parola ’GNU’ quando indica il
nome di questo progetto. [N.d.T.: questa avvertenza serve ad evitare che in inglese "GNU" sia
pronunciato come la parola "new"].
Perché devo scrivere GNU
Io credo che il punto fondamentale sia che, se a me piace un programma, io debba condividerlo
con altre persone a cui piace. I venditori di software usano il criterio "divide et impera" con
gli utenti, facendo sì che non condividano il software con altri. Io mi rifiuto di spezzare così
la solidarietà con gli altri utenti. La mia coscienza non mi consente di firmare un accordo per
non rivelare informazioni o per una licenza d’uso del software. Ho lavorato per anni presso
il laboratorio di intelligenza artificiale per resistere a queste tendenze e ad altri atteggiamenti
sgradevoli, ma col tempo queste sono andate troppo oltre: non potevo rimanere in una istituzione
dove ciò viene fatto a mio nome contro la mia volontà.
Per poter continuare ad usare i computer senza disonore, ho deciso di raccogliere un corpus di
software libero in modo da andare avanti senza l’uso di alcun software che non sia libero. Mi
sono dimesso dal laboratorio di Intelligenza Artificiale per togliere al MIT ogni scusa legale che
mi impedisca di distribuire GNU.
Perché GNU sarà compatibile con Unix
Unix non è il mio sistema ideale, ma non è poi così male. Le caratteristiche essenziali di Unix
paiono essere buone e penso di poter colmare le lacune di Unix senza rovinarne le caratteristiche.
E adottare un sistema compatibile con Unix può risultare pratico anche per molti altri.
Come sarà reso disponibile GNU
GNU non è di pubblico dominio. A tutti sarà permesso di modificare e ridistribuire GNU, ma a
nessun distributore sarà concesso di porre restrizioni sulla sua ridistribuzione. Questo vuol dire
che non saranno permesse modifiche proprietarie. Voglio essere sicuro che tutte le versioni di
GNU rimangano libere.
Perché molti altri programmatori desiderano essere d’aiuto
Ho trovato molti altri programmatori molto interessati a GNU che vogliono dare una mano.
Molti programmatori sono scontenti della commercializzazione del software di sistema. Li può
aiutare a far soldi, ma li costringe in generale a sentirsi in conflitto con gli altri programmatori,
invece che solidali. L’atto di amicizia fondamentale tra programmatori è condividere programmi;
le politiche di commercializzazione attualmente in uso essenzialmente proibiscono ai program-
4296
Manifesto GNU
matori di trattare gli altri come amici. Gli acquirenti del software devono decidere tra l’amicizia
e l’obbedienza alle leggi. Naturalmente molti decidono che l’amicizia è più importante. Ma quelli che credono nella legge non si sentono a proprio agio con queste scelte. Diventano cinici e
pensano che programmare sia solo un modo per fare soldi.
Lavorando e utilizzando GNU invece che programmi proprietari, possiamo comportarci amichevolmente con tutti e insieme rispettare la legge. Inoltre GNU è un esempio che ispira gli altri e
una bandiera che li chiama a raccolta perché si uniscano a noi nel condividere il software. Questo
ci può dare una sensazione di armonia che sarebbe irraggiungibile se usassimo software che non
sia libero. Per circa la metà dei programmatori che conosco è una soddisfazione importante, che
il denaro non può sostituire.
Come si può contribuire
Chiedo ai produttori di computer donazioni in denaro e macchine, ed ai privati donazioni in
programmi e lavoro.
Donare delle macchine può far sì che su di esse giri ben presto GNU. Le macchine devono
essere sistemi completi e pronti all’uso approvati per l’utilizzo in aree residenziali e non devono
richiedere raffreddamento o alimentazione di tipo sofisticato.
Ho conosciuto moltissimi programmatori desiderosi di contribuire a GNU part-time. Per la gran
parte dei progetti, un lavoro part-time distribuito risulterebbe troppo difficile da coordinare, perché le varie parti scritte indipendentemente non funzionerebbero insieme. Ma per scrivere un
sostituto di Unix questo problema non si pone, perché un sistema Unix completo contiene centinaia di programmi di servizio, ognuno con la propria documentazione separata, e con gran parte
delle specifiche di interfaccia date dalla compatibilità con Unix. Se ogni partecipante scrive un
solo programma da usare al posto di una utility di Unix, il quale funzioni correttamente al posto
dell’originale su un sistema Unix, allora questi programmi funzioneranno bene una volta messi
assieme. Anche considerando qualche imprevisto dovuto a Murphy, assemblare tali componenti
è un lavoro fattibile. Il kernel invece richiederà una più stretta cooperazione, e verrà sviluppato
da un gruppo piccolo e affiatato.
Donazioni in denaro possono mettermi in grado di assumere alcune persone a tempo pieno o parttime. Lo stipendio non sarà alto rispetto agli standard dei programmatori, ma io cerco persone
per le quali lo spirito della comunità GNU sia importante quanto il denaro. Io lo vedo come un
modo di permettere a degli appassionati di dedicare tutte le loro energie al lavoro su GNU senza
essere costretti a guadagnarsi da vivere in un altro modo.
Perché tutti gli utenti dei computer ne trarranno beneficio
Una volta scritto GNU, ognuno potrà avere liberamente del buon software di sistema, così come
può avere l’aria.2
Questo significa molto di più che far risparmiare a ciascuno il costo di una licenza Unix: vuol dire
evitare l’inutile spreco di ripetere ogni volta lo sforzo della programmazione di sistema. Queste
energie possono essere invece impiegate ad avanzare lo stato dell’arte.
I sorgenti completi del sistema saranno a disposizione di tutti. Di conseguenza, un utente che
abbia necessità di apportare dei cambiamenti al sistema sarà sempre in grado di farlo da solo o
di commissionare i cambiamenti ad un programmatore o ad un’impresa. Gli utenti non saranno
più in balia di un solo programmatore o di una impresa che, avendo la proprietà esclusiva dei
sorgenti, sia la sola a poter fare le modifiche.
2
Questo è un altro punto dove non sono riuscito a distinguere chiaramente tra i due significati di "free". La frase, così
com’è, non è falsa, si possono ottenere gratuitamente copie del software GNU, o dagli amici o attraverso la rete. Ma in
effetti suggerisce un’idea sbagliata.
Manifesto GNU
4297
Le scuole avranno la possibilità di fornire un ambiente molto più educativo, incoraggiando gli
studenti a studiare e migliorare il software di sistema. I laboratori di informatica di Harvard avevano una politica per cui nessun programma poteva essere installato nel sistema senza che i sorgenti fossero pubblicamente consultabili, e la praticarono rifiutandosi effettivamente di installare
alcuni programmi. Questo comportamento mi è stato di grande ispirazione.
Infine, scompariranno le necessità burocratiche di tener conto di chi sia il proprietario del
software di sistema e di chi abbia il diritto di farci cosa.
Ogni sistema per imporre tariffe d’uso di un programma, comprese le licenze d’uso per le copie,
è sempre estremamente costoso in termini sociali a causa del complesso meccanismo necessario
per decidere quanto (cioè per quali programmi) ognuno debba pagare, e solo uno stato di polizia
può costringere tutti all’obbedienza. Immaginate una stazione spaziale dove l’aria deve essere
prodotta artificialmente ad un costo elevato: far pagare ogni litro d’aria consumato può essere
giusto, ma indossare la maschera col contatore tutto il giorno e tutta la notte è intollerabile,
anche se tutti possono permettersi di pagare la bolletta. E le videocamere poste in ogni dove per
controllare che nessuno si tolga mai la maschera sono offensive. Meglio finanziare l’impianto di
ossigenazione con una tassa pro capite e buttar via le maschere.
Copiare un programma in tutto o in parte è tanto naturale per un programmatore quanto respirare
ed è altrettanto produttivo. Dovrebbe essere altrettanto libero.
Alcune obiezioni facilmente confutabili agli obiettivi GNU
«La gente non lo userà se è gratuito, perché non potrà avere l’assistenza.»
«Un programma deve essere a pagamento, per poter fornire supporto adeguato.»
Se la gente preferisse pagare per GNU più l’assistenza piuttosto che avere GNU gratis senza
assistenza, allora un’impresa che fornisse assistenza a chi si è procurato GNU gratis potrebbe
operare con profitto.3
Si deve distinguere tra il supporto sotto forma di lavoro di programmazione e la semplice gestione. Il primo non è ottenibile da un venditore di software. Se il problema non è sentito da un
numero sufficiente di clienti allora il venditore dirà al cliente di arrangiarsi.
Per chi deve poter contare su questo tipo di supporto l’unica soluzione è di disporre dei sorgenti
e degli strumenti necessari, in modo da poter commissionare il lavoro a chi sia disposto a farlo,
invece che rimanere in balia di qualcuno. Con Unix il prezzo dei sorgenti rende ciò improponibile
per la maggior parte delle imprese. Con GNU questo sarà invece facile. Si darà sempre il caso
che non siano disponibili persone competenti, ma questo non potrà essere imputato al sistema di
distribuzione. GNU non elimina tutti i problemi del mondo, solo alcuni.
Allo stesso tempo, gli utenti che non sanno nulla di computer hanno bisogno di manutenzione,
cioè di cose che potrebbero fare facilmente da soli ma che non sono in grado di fare.
Servizi di questo genere potrebbero essere forniti da aziende che vendono solo gestione e manutenzione. Se è vero che gli utenti sono disposti a pagare per un prodotto con servizio, allora
saranno anche disposti a pagare per il servizio avendo avuto il prodotto gratuitamente. Le aziende
di servizi si faranno concorrenza sul prezzo e sulla qualità; gli utenti d’altra parte non saranno
legati a nessuna di esse in particolare. Nel frattempo, coloro che non avranno bisogno del servizio
saranno sempre in grado di usare il programma senza pagare il servizio.
«Non si può raggiungere molta gente senza pubblicità, e per finanziarla si deve far pagare il
programma.»
«È inutile reclamizzare un programma gratuito.»
3
Adesso esistono effettivamente molte ditte di questo tipo.
4298
Manifesto GNU
Ci sono molte forme di pubblicità gratuita o a basso costo che possono essere usate per informare
un gran numero di utenti di computer riguardo a cose come GNU. Ma può essere vero che la
pubblicità può raggiungere molti più utenti di microcomputer. Se fosse veramente così, una ditta
che reclamizzasse il servizio di copia e spedizione per posta di GNU a pagamento dovrebbe
aver abbastanza successo commerciale da rientrare dai costi della pubblicità e da guadagnarci. In
questo modo, pagano la pubblicità solo gli utenti che ne beneficiano.
D’altro canto, se molta gente ottiene GNU da amici e queste aziende non hanno successo, vorrà
dire che la pubblicità non era necessaria per diffondere GNU. Perché tutti questi difensori del
libero mercato non vogliono lasciare che sia il libero mercato a decidere?4
«La mia azienda ha bisogno di un sistema operativo proprietario per essere più avanti della
concorrenza.»
Con GNU, i sistemi operativi non rientreranno più fra gli elementi di concorrenza. La vostra
azienda non potrà essere concorrenziale in quest’area, ma egualmente non potranno esserlo i
concorrenti. Vi farete concorrenza in altre aree, mentre in questa godrete di mutui benefici. Se
vendete sistemi operativi non apprezzerete GNU, ma è un problema vostro. Se avete un’attività
di altro tipo, GNU vi può evitare di essere spinti nel costoso campo della vendita di sistemi
operativi.
Mi piacerebbe che lo sviluppo di GNU fosse sostenuto da donazioni da parte di numerosi
produttori ed utenti, riducendo così la spesa per tutti.5
«Ma i programmatori non meritano una ricompensa per la loro creatività?»
Se qualcosa merita una ricompensa questo è il contribuire al bene sociale. La creatività può essere
un contributo al bene sociale, ma solo nella misura in cui la società è libera di usarne i risultati.
Se i programmatori meritano una ricompensa per la creazione di programmi innovativi, allora
con la stessa logica meritano una punizione se pongono restrizioni all’uso di questi programmi.
«Un programmatore non dovrebbe poter chiedere una ricompensa per la sua creatività?»
Non c’è niente di male nel chiedere di esser pagati per il proprio lavoro, o mirare ad incrementare
le proprie entrate, fintanto che non si utilizzino metodi che siano distruttivi. Ma i metodi comuni
nel campo del software, al giorno d’oggi, sono distruttivi.
Spremere denaro dagli utenti di un programma imponendo restrizioni sull’uso è distruttivo perché
riduce i modi in cui il programma può essere usato. Questo diminuisce la quantità di ricchezza
che l’umanità ricava dal programma. Quando c’è una scelta deliberata di porre restrizioni, le
conseguenze dannose sono distruzione deliberata.
La ragione per cui un buon cittadino non usa questi metodi distruttivi per diventare più ricco è che,
se lo facessero tutti, diventeremmo tutti più poveri a causa delle distruzioni reciproche. Questa
è etica kantiana, la Regola Aurea: poiché non mi piacciono le conseguenze che risulterebbero
se tutti impedissero l’accesso alle informazioni, devo considerare sbagliato che uno lo faccia.
In particolare, il desiderio di una ricompensa per la propria creatività non giustifica il privare il
mondo nel suo insieme di tutta o parte di questa creatività.
«Ma i programmatori non moriranno di fame?»
4
La Free Software Foundation raccoglie la maggior parte dei suoi fondi da un servizio di distribuzione, anche se
è più un ente senza fini di lucro che un’azienda. Se *nessuno* sceglie di ottenere copie del software ordinandole alla
FSF, questa sarà impossibilitata a proseguire la propria opera. Ma questo non vuole dire che siano giustificate restrizioni
proprietarie per costringere gli utenti a pagare. Se una piccola frazione degli utenti ordina le sue copie dalla FSF, questo
sarà sufficiente per tenerla a galla. Quindi chiediamo agli utenti di aiutarci in questo modo. Hai fatto la tua parte?
5
Un gruppo di imprese di software ha recentemente costituito dei finanziamenti per sostenere la manutenzione del
nostro compilatore C.
Manifesto GNU
4299
Potrei rispondere che nessuno è obbligato a fare il programmatore. La maggior parte di noi non è
in grado di andare per strada a fare il mimo, ma ciò non vuol dire che siamo condannati a passare
la vita per strada a fare i mimi, e morire di fame. Facciamo un altro lavoro.
Ma è la risposta sbagliata, perché accetta l’assunzione implicita di chi pone la domanda, e cioè
che senza proprietà del software non è possibile pagare ai programmatori il becco di un quattrino.
Un’assunzione del tipo tutto o niente.
La vera ragione per cui i programmatori non moriranno di fame è che sarà per loro egualmente
possibile essere pagati per programmare, solo non pagati così tanto come ora.
Porre restrizioni sulle copie non è l’unico modello di affari nel campo del software. È il modello
più comune perché è il più redditizio. Se fosse vietato, o rifiutato dagli utenti, l’industria del
software si sposterebbe su altri modelli organizzativi, adottandone altri ora meno comuni. Ci
sono sempre numerosi modi per organizzare un qualunque tipo di affari.
Probabilmente programmare nel nuovo modello organizzativo non sarà più così redditizio come lo è ora. Ma questo non è un argomento contro il cambiamento. Che gli addetti alle vendite
ricevano i salari che ora ricevono non è considerata un’ingiustizia. Se i programmatori avessero gli stessi stipendi (in pratica guadagnerebbero molto di più), non sarebbe nemmeno quella
un’ingiustizia.
«Ma le persone non hanno diritto di controllare come la loro creatività viene usata?»
Il "controllo sull’uso delle proprie idee" in realtà costituisce un controllo sulle vite degli altri; e
di solito viene usato per rendere più difficili le loro vite.
Le persone che hanno studiato con cura i vari aspetti del diritto alla proprietà intellettuale (come
gli avvocati) dicono che non c’è alcun diritto intrinseco alla proprietà intellettuale. I tipi dei
supposti diritti alla proprietà intellettuale riconosciuti dal governo furono creati da specifici atti
legislativi per scopi specifici.
Per esempio la legislazione sui brevetti fu introdotta per incoraggiare gli inventori a rivelare i
dettagli delle loro invenzioni. Lo scopo era avvantaggiare la società più che avvantaggiare gli
inventori. A quel tempo la validità di 17 anni per un brevetto era breve se confrontata con la
velocità di avanzamento dello stato dell’arte. Poiché i brevetti riguardano solo i produttori, per
i quali il costo e lo sforzo degli accordi di licenza sono piccoli in confronto all’organizzazione
della produzione, spesso i brevetti non costituiscono un gran danno. E non ostacolano la gran
parte degli individui che usano prodotti coperti da brevetto.
L’idea del copyright non esisteva in tempi antichi, quando gli autori copiavano estesamente altri
autori in opere non narrative. Questa pratica era utile, ed è il solo modo attraverso cui almeno
parte del lavoro di alcuni autori è sopravvissuto. La legislazione sul copyright fu creata espressamente per incoraggiare l’originalità. Nel campo per cui fu inventata, cioè i libri, che potevano
essere copiati a basso costo solo con apparecchiature tipografiche, non fece molto danno e non
pose ostacoli alla maggior parte dei lettori.
Tutti i diritti di proprietà intellettuale sono solo licenze concesse dalla società perché si riteneva,
correttamente o meno, che concederle avrebbe giovato alla società nel suo complesso. Ma data una situazione particolare dobbiamo chiederci: facciamo realmente bene a concedere queste
licenze? Che atti permettiamo di compiere con esse?
Il caso dei programmi ai giorni nostri differisce enormemente da quello dei libri un secolo fa. Il
fatto che la via più facile per passare una copia di un programma sia da persona a persona, che il
programma abbia un codice sorgente ed un codice oggetto che sono cose distinte, ed infine il fatto
che un programma venga usato più che letto e gustato, combinandosi creano una situazione in
cui qualcuno che impone un copyright minaccia la società nel suo insieme, sia materialmente che
4300
Manifesto GNU
spiritualmente, una situazione in cui quel qualcuno non dovrebbe farlo, che la legge lo permetta
o no.
«La competizione fa sì che le cose siano fatte meglio.»
Il paradigma della competizione è la gara: premiando il vincitore incoraggia ognuno a correre più
veloce. Quando veramente il capitalismo funziona in questo modo, fa un buon lavoro; ma chi lo
difende ha torto nell’asserire che agisce sempre così. Se i corridori dimenticano il motivo per cui
è offerto il premio e si concentrano solo sul vincere non curandosi di come, possono trovare altre
strategie, come ad esempio attaccare gli altri concorrenti. Se i corridori si azzuffano, arrivano
tutti in ritardo al traguardo.
Il software proprietario e segreto è l’equivalente morale dei corridori che si azzuffano. Triste a
dirsi, l’unico arbitro che abbiamo pare non muovere alcuna obiezione alle zuffe, al più le regolamenta ("ogni dieci metri puoi tirare un pugno"). Dovrebbe invece dividerli e penalizzarli anche
se solo provassero a combattere.
«Ma senza un incentivo economico non smetterebbero tutti di programmare?»
In realtà molta gente programmerebbe senza alcun incentivo economico. Programmare ha un
fascino irresistibile per alcune persone, solitamente per quelli che ci riescono meglio. Non mancano certo i musicisti professionisti che insistono pur non avendo speranza di guadagnarsi da
vivere suonando.
Ma in realtà questa domanda, benché posta spesso, non è appropriata. La paga per i programmatori non sparirà, semplicemente diminuirà. Quindi la domanda corretta è: «qualcuno si metterà
mai a programmare per un minore incentivo economico?». La mia esperienza dice che sì, ci si
metterà.
Per più di dieci anni molti tra i migliori programmatori del mondo hanno lavorato nel laboratorio
di Intelligenza Artificiale per molti meno soldi di quanti ne avrebbero potuti ricevere in ogni
altro posto. Hanno avuto soddisfazioni non economiche di moltissimi tipi, ad esempio fama e
riconoscenza. E la creatività è anche divertente, un premio di per sé.
Poi molti se ne sono andati quando hanno avuto la possibilità di fare lo stesso interessante lavoro
per un mucchio di soldi.
Ciò che i fatti mostrano è che la gente programma per altre ragioni che non siano il denaro; ma
se viene data la possibilità di fare la stessa cosa per un mucchio di soldi, allora cominceranno ad
aspettarseli e a richiederli. Le organizzazioni che pagano poco sono svantaggiate in confronto a
quelle che pagano molto, ma non sarebbero necessariamente in questa posizione se quelle che
pagano molto fossero bandite.
«Abbiamo un disperato bisogno dei programmatori. Se ci chiedono di smettere di aiutare i nostri
vicini dobbiamo obbedire.»
Non si è mai così disperati da dover obbedire a questo genere di pretese. Ricorda: milioni in
difesa, ma non un centesimo in tributi [N.d.T.: è una famosa frase di George Washington].
«I programmatori devono guadagnarsi da vivere in qualche modo.»
A breve termine è vero. Ma ci sono un’infinità di modi in cui i programmatori possono guadagnarsi da vivere senza vendere i diritti d’uso dei programmi. Questo metodo è comune ai giorni
nostri perché porta la maggior quantità di denaro a programmatori e aziende, non perché sia l’unica strada per guadagnarsi da vivere. È facile trovarne altre se se ne vogliono trovare. Ecco una
serie di esempi.
Un produttore che immette sul mercato un nuovo computer pagherà per il porting dei sistemi
operativi sul nuovo hardware.
Manifesto GNU
4301
I servizi a pagamento di insegnamento, gestione e manutenzione possono impiegare dei
programmatori.
Persone con idee nuove possono distribuire i programmi gratuitamente, chiedendo donazioni
agli utenti soddisfatti, o vendendo servizi di gestione. Ho incontrato persone che già lavorano
con successo in questo modo.
Utenti con necessità simili possono formare gruppi e pagare. Un gruppo potrebbe stipulare un
contratto con un’impresa di programmazione per scrivere i programmi che i membri del gruppo
vorrebbero usare.
Tutti i tipi di sviluppo possono essere finanziati da una Tassa per il Software:
Supponiamo che chiunque compri un computer debba pagare un x per cento del costo del computer come tassa per il software. Il governo girerebbe questi fondi ad un’agenzia come la NSF
[N.d.T.: più o meno l’equivalente del nostro CNR] per impiegarli nello sviluppo del software.
Ma se l’acquirente fa lui stesso una donazione per lo sviluppo del software, potrebbe ottenere
un credito nei confronti di queste tasse. Potrebbe fare una donazione ad un progetto di sua scelta
-- tipicamente scelto perché spera di usarne i risultati quando questo verrà completato. Potrebbe
ottenere un credito per ogni donazione fatta, fino al valore totale della tassa che dovrebbe pagare.
Il gettito complessivo di questa tassa potrebbe essere deciso dal voto di chi la paga, pesato
secondo l’ammontare pagato.
Le conseguenze:
• La comunità degli utenti di computer sosterrebbe lo sviluppo del software.
• La comunità sceglierebbe il livello di sostegno necessario.
• Gli utenti che fossero interessati a sapere su che progetto vengano spesi i loro soldi
avrebbero la possibilità di gestire personalmente la cosa.
Nel lungo periodo, rendere liberi i programmi è un passo verso l’epoca della fine del bisogno,
quando nessuno sarà obbligato a lavorare molto duramente solo per guadagnarsi di che vivere.
La gente sarà libera di dedicarsi ad attività divertenti, come programmare, dopo aver passato le
dieci ore settimanali necessarie in compiti come legiferare, fare consulenza familiare, riparare i
robot e prevedere il moto degli asteroidi. Non ci sarà bisogno di guadagnarsi da vivere con la
programmazione.
Abbiamo già ridotto moltissimo la quantità di lavoro che la società nel suo complesso deve fare
per ottenere la sua produttività attuale, ma poco di questo si è tradotto in benessere per i lavoratori
perché è necessario accompagnare l’attività produttiva con molta attività non produttiva. Le cause
principali sono la burocrazia e gli sforzi a tutto campo contro la concorrenza. Il software libero
ridurrà di molto questo drenaggio di risorse nell’area della produzione del software. Dobbiamo
farlo affinché i guadagni tecnici in produttività si traducano in meno lavoro per noi.
Capitolo
376
Il progetto GNU
non modificabile
Testo originale: <http://www.fsf.org/gnu/the-gnu-project.html>
Traduzione originale: <http://www.fsf.org/gnu/thegnuproject.it.html>
Copyright © 1998 Richard Stallman
La copia letterale e la distribuzione di questo articolo nella sua integrità sono permesse con ogni
mezzo, a patto che questa nota sia riprodotta.
1
376.1 La prima comunità di condivisione del software
Quando cominciai a lavorare nel laboratorio di Intelligenza Artificiale del MIT [N.d.T. Massachusset Institute of Technology] nel 1971, entrai a far parte di una comunità in cui ci si scambiavano i programmi, che esisteva già da molti anni. La condivisione del software non si limitava
alla nostra comunità; è un cosa vecchia quanto i computer, proprio come condividere le ricette è
antico come il cucinare. Ma noi lo facevamo più di quasi chiunque altro.
Il laboratorio di Intelligenza Artificiale usava un sistema operativo a partizione di tempo (timesharing) chiamato ITS (Incompatible Timesharing System) che il gruppo di hacker2 del laboratorio aveva progettato e scritto in linguaggio assembler per il Digital PDP-10, uno dei grossi
elaboratori di quel periodo. Come membro di questa comunità, hacker di sistema nel gruppo
laboratorio, il mio compito era migliorare questo sistema.
Non chiamavamo il nostro software "software libero", poiché questa espressione ancora non esisteva, ma si trattava proprio di questo. Quando persone di altre università o di qualche società volevano convertire il nostro programma per il proprio sistema ed utilizzarlo, erano le benvenute. Se
si vedeva qualcuno usare un programma sconosciuto ed interessante, si poteva sempre chiedere di
vederne il codice sorgente, in modo da poterlo leggere, modificare, o prenderne (cannibalizzarne)
alcune parti per creare un nuovo programma.
376.2 La comunità si dissolve
La situazione cambiò drasticamente all’inizio degli anni ’80 quando la Digital smise di produrre
la serie PDP-10. La sua architettura, elegante e potente negli anni ’60, non poteva essere estesa in
modo naturale ai più grandi spazi di indirizzamento che si stavano rendendo possibili negli anni
’80. Questo significò che quasi tutti i programmi che formavano ITS divennero obsoleti.
La comunità di hacker del laboratorio di Intelligenza Artificiale si era già dissolta non molto
tempo prima. Nel 1981 la Symbolics, nata da una costola del laboratorio stesso, gli aveva sottratto
quasi tutti gli hacker; l’ormai esiguo gruppo rimasto fu dunque incapace di sostenersi (il libro
"Hackers" di Steve Levy narra questi eventi, oltre a fornire una fedele ricostruzione di questa
1
[NdR: il testo che appare qui è stato ritoccato leggermente per correggere alcuni errori evidenti.]
L’uso del termine "hacker" nel senso di "pirata" è una confusione di termini creata dai mezzi di informazione. Noi
hacker ci rifiutiamo di riconoscere questo significato, e continuiamo ad utilizzare la parola nel senso di "uno che ami
programmare, e a cui piaccia essere bravo a farlo".
2
4302
Il progetto GNU
4303
comunità ai suoi inizi). Quando il laboratorio di Intelligenza Artificiale nel 1982 acquistò un
nuovo PDP-10, i sistemisti decisero di utilizzare il sistema timesharing non libero della Digital
piuttosto che ITS.
I moderni elaboratori di quell’epoca, come il VAX o il 68020, avevano il proprio sistema operativo, ma nessuno di questi era libero: si doveva firmare un accordo di non-diffusione persino per
ottenerne una copia eseguibile.
Questo significava che il primo passo per usare un computer era promettere di negare aiuto al
proprio vicino. Una comunità cooperante era vietata. La regola creata dai proprietari di software
proprietario era: «se condividi il software col tuo vicino sei un pirata. Se vuoi modifiche, pregaci
di farle».
L’idea che la concezione sociale di software proprietario -- cioè il sistema che impone che il
software non possa essere condiviso o modificato -- sia antisociale, contraria all’etica, semplicemente sbagliata, può apparire sorprendente a qualche lettore. Ma che altro possiamo dire di un
sistema che si basa sul dividere utenti e lasciarli senza aiuto? Quei lettori che trovano sorprendente l’idea possono aver data per scontata la concezione sociale di software proprietario, o averla
giudicata utilizzando lo stesso metro suggerito dal mercato del software proprietario. I produttori
di software hanno lavorato a lungo e attivamente per diffondere la convinzione che c’è un solo
modo di vedere la cosa.
Quando i produttori di software parlano di "difendere" i propri "diritti" o di "fermare la pirateria", quello che dicono è in realtà secondario. Il vero messaggio in quelle affermazioni sta nelle
assunzioni inespresse, che essi danno per scontate; vogliono che siano accettate acriticamente.
Esaminiamole, dunque.
Una prima assunzione è che le aziende produttrici di software abbiano il diritto naturale indiscutibile di proprietà sul software, e di conseguenza, abbiano controllo su tutti i suoi utenti. Se
questo fosse un diritto naturale, non potremmo sollevare obiezioni, indipendentemente dal danno che possa recare ad altri. È interessante notare che, negli Stati Uniti, sia la costituzione che
la giurisprudenza rifiutano questa posizione: il diritto d’autore non è un diritto naturale, ma un
monopolio imposto dal governo che limita il diritto naturale degli utenti ad effettuare delle copie.
Un’altra assunzione inespressa è che la sola cosa importante del software sia il lavoro che consente di fare -- vale a dire che noi utenti non dobbiamo preoccuparci del tipo di società in cui ci
è permesso vivere.
Una terza assunzione è che non avremmo software utilizzabile (o meglio, che non potremmo mai
avere un programma per fare questo o quell’altro particolare lavoro) se non riconoscessimo ai
produttori il controllo sugli utenti di quei programmi. Questa assunzione avrebbe potuto sembrare
plausibile, prima che il movimento del software libero dimostrasse che possiamo scrivere quantità
di programmi utili senza bisogno di metterci dei catenacci.
Se rifiutiamo di accettare queste assunzioni, giudicando queste questioni con comuni criteri di
moralità e di buon senso dopo aver messo al primo posto gli interessi degli utenti, tenendo conto
che gli utenti vengono prima di tutto, arriviamo a conclusioni del tutto differenti. Chi usa un
calcolatore dovrebbe essere libero di modificare i programmi per adattarli alle proprie necessità,
ed essere libero di condividere il software, poiché aiutare gli altri è alla base della società.
Non c’è modo in questa sede di trattare approfonditamente i ragionamenti che portano a questa
conclusione; il lettore interessato può cercare le informazioni in rete a questo indirizzo: <http://
www.gnu.org/philosophy/why-free.html>.
Il progetto GNU
4304
376.3 Una difficile scelta morale
Una volta che il mio gruppo si fu sciolto, continuare come prima fu impossible. Mi trovai di
fronte ad una difficile scelta morale.
La scelta facile sarebbe stata quella di unirsi al mondo del software proprietario, firmando accordi
di non-diffusione e promettendo di non aiutare i miei compagni hacker. Con ogni probabilità
avrei anche sviluppato software che sarebbe stato distribuito secondo accordi di non-diffusione,
contribuendo così alla pressione su altri perché a loro volta tradissero i propri compagni.
In questo modo avrei potuto guadagnare, e forse mi sarei divertito a programmare. Ma sapevo
che al termine della mia carriera mi sarei voltato a guardare indietro, avrei visto anni spesi a
costruire muri per dividere le persone, e avrei compreso di aver contribuito a rendere il mondo
peggiore.
Avevo già sperimentato cosa significasse un accordo di non diffusione per chi lo firmava, quando
qualcuno rifiutò a me e al laboratorio AI del MIT il codice sorgente del programma di controllo
della nostra stampante; l’assenza di alcune funzionalità nel programma rendeva oltremodo frustrante l’uso della stampante. Per cui non mi potevo dire che gli accordi di non-diffusione fossero
innocenti. Ero molto arrabbiato quando quella persona si rifiutò di condividere il programma con
noi; non potevo far finta di niente e fare lo stesso con tutti gli altri.
Un’altra possibile scelta, semplice ma spiacevole, sarebbe stata quella di abbandonare l’informatica. In tal modo le mie capacità non sarebbero state mal utilizzate, tuttavia sarebbero state
sprecate. Non sarei mai stato colpevole di dividere o imporre restrizioni agli utenti di calcolatori,
ma queste cose sarebbero comunque successe.
Allora cercai un modo in cui un programmatore potesse fare qualcosa di buono. Mi chiesi dunque:
c’erano un programma o dei programmi che io potessi scrivere, per rendere nuovamente possibile
l’esistenza di una comunità?
La risposta era semplice: innanzitutto serviva un sistema operativo. Questo è difatti il software
fondamentale per iniziare ad usare un computer. Con un sistema operativo si possono fare molte
cose; senza, non è proprio possibile far funzionare il computer. Con un sistema operativo libero,
avremmo potuto avere nuovamente una comunità in cui hacker possono cooperare, e invitare
chiunque ad unirsi al gruppo. E chiunque sarebbe stato in grado di usare un calcolatore, senza
dover cospirare fin dall’inizio per sottrarre qualcosa ai propri amici.
Essendo un programmatore di sistemi, possedevo le competenze adeguate per questo lavoro.
Così, anche se non davo il successo per scontato, mi resi conto di essere la persona giusta per
farlo. Scelsi di rendere il sistema compatibile con Unix, in modo che fosse portabile, e che gli
utenti Unix potessero passare facilmente ad esso. Il nome GNU fu scelto secondo una tradizione
hacker, come acronimo ricorsivo che significa "GNU’s Not Unix" [N.d.T. GNU non è Unix].
Un sistema operativo non si limita solo al suo nucleo, che è proprio il minimo per eseguire
altri programmi. Negli anni ’70, qualsiasi sistema operativo degno di questo nome includeva
interpreti di comandi, assemblatori, compilatori, interpreti di linguaggi, debugger, editor di testo,
programmi per la posta e molto altro. ITS li aveva, Multics li aveva, VMS li aveva e Unix li
aveva. Anche il sistema operativo GNU li avrebbe avuti.
Tempo dopo venni a conoscenza di questa massima, attribuita a Hillel:
3
Se non sono per me stesso, chi sarà per me?
3
Essendo ateo, non seguo alcuna guida religiosa, ma a volte mi trovo ad ammirare qualcosa che qualcuno di loro ha
detto.
Il progetto GNU
4305
E se sono solo per me stesso, che cosa sono?
E se non ora, quando?
La decisione di iniziare il progetto GNU si basò su uno spirito simile.
376.4 "Free" come libero
Il termine "free software" [N.d.T. il termine free in inglese significa sia gratuito che libero] a volte
è mal interpretato: non ha niente a che vedere col prezzo del software; si tratta di libertà. Ecco,
dunque, la definizione di software libero: un programma è software libero per un dato utente se:
• l’utente ha la libertà di eseguire il programma per qualsiasi scopo;
• l’utente ha la libertà di modificare il programma secondo i propri bisogni (perché questa libertà abbia qualche effetto in pratica, è necessario avere accesso al codice sorgente
del programma, poiché apportare modifiche ad un programma senza disporre del codice
sorgente è estremamente difficile);
• l’utente ha la libertà di distribuire copie del programma, gratuitamente o dietro compenso;
• l’utente ha la libertà di distribuire versioni modificate del programma, così che la comunità
possa fruire dei miglioramenti apportati.
Poiché "free" si riferisce alla libertà e non al prezzo, vendere copie di un programma non contraddice il concetto di software libero. In effetti, la libertà di vendere copie di programmi è essenziale:
raccolte di software libero vendute su CD-ROM sono importanti per la comunità, e la loro vendita è un modo di raccogliere fondi importante per lo sviluppo del software libero. Di conseguenza,
un programma che non può essere liberamente incluso in tali raccolte non è software libero.
A causa dell’ambiguità del termine "free", si è cercata a lungo un’alternativa, ma nessuno ne ha
trovata una valida. La lingua inglese ha più termini e sfumature di ogni altra, ma non ha una
parola semplice e non ambigua che significhi libero; "unfettered" è la parola più vicina come
significato [NdT: unfettered è una parola di tono aulico o arcaico che significa libero da ceppi,
vincoli o inibizioni]. Alternative come "liberated", "freedom" e "open" hanno altri significati o
non sono adatte per altri motivi [NdT: rispettivamente, liberato, libertà, aperto].
376.5 Software GNU e il sistema GNU
Sviluppare un intero sistema è un progetto considerevole. Per raggiungere l’obiettivo decisi di
adattare e usare parti di software libero tutte le volte che fosse possibile. Per esempio, decisi fin
dall’inizio di usare TeX come il principale programma di formattazione di testo; qualche anno
più tardi, decisi di usare l’X Window System piuttosto che scrivere un altro sistema a finestre per
GNU.
A causa di questa decisione, il sistema GNU e la raccolta di tutto il software GNU non sono
la stessa cosa. Il sistema GNU comprende programmi che non sono GNU, sviluppati da altre
persone o gruppi di progetto per i propri scopi, ma che possiamo usare in quanto software libero.
4306
Il progetto GNU
376.6 L’inizio del progetto
Nel gennaio 1984 lasciai il mio posto al MIT e cominciai a scrivere software GNU. Dovetti
lasciare il MIT, per evitare che potesse interferire con la distribuzione di GNU come software
libero. Se fossi rimasto, il MIT avrebbe potuto rivendicare la proprietà del lavoro, ed avrebbe
potuto imporre i propri termini di distribuzione, o anche farne un pacchetto proprietario. Non
avevo alcuna intenzione di fare tanto lavoro solo per vederlo reso inutilizzabile per il suo scopo
originario: creare una nuova comunità di condivisione di software. Ad ogni buon conto, il professor Winston -- allora responsabile del laboratorio AI del MIT -- mi propose gentilmente di
continuare ad utilizzare le attrezzature del laboratorio stesso.
376.7 I primi passi
Poco dopo aver iniziato il progetto GNU, venni a sapere del Free University Compiler Kit, noto
anche come VUCK (la parola olandese che sta per "free" inizia con la V). Era un compilatore
progettato per trattare più linguaggi, fra cui C e Pascal, e per generare codice binario per diverse architetture. Scrissi al suo autore chiedendo se GNU avesse potuto usarlo. Rispose in modo
canzonatorio, dicendo che l’università era sì libera, ma non il compilatore. Decisi allora che
il mio primo programma per il progetto GNU sarebbe stato un compilatore multilinguaggio e
multipiattaforma.
Sperando di evitare di dover scrivere da me l’intero compilatore, ottenni il codice sorgente del
Pastel, un compilatore multipiattaforma sviluppato ai Laboratori Lawrence Livermore. Il linguaggio supportato da Pastel, in cui il Pastel stesso era scritto, era una versione estesa del Pascal,
pensata come linguaggio di programmazione di sistemi. Io vi aggiunsi un frontend per il C, e cominciai il porting per il processore Motorola 68000, ma fui costretto a rinunciare quando scoprii
che il compilatore richiedeva diversi megabyte di memoria sullo stack, mentre il sistema Unix
disponibile per il processore 68000 ne permetteva solo 64K.
Mi resi conto allora che il compilatore Pastel interpretava tutto il file di ingresso creandone un
albero sintattico, convertiva questo in una catena di "istruzioni", e quindi generava l’intero file di
uscita senza mai liberare memoria. A questo punto, conclusi che avei dovuto scrivere un nuovo
compilatore da zero. Quel nuovo compilatore è ora noto come Gcc; non utilizza niente del compilatore Pastel, ma riuscii ad adattare e riutilizzare il frontend per il C che avevo scritto. Questo
però avvenne qualche anno dopo; prima, lavorai su GNU Emacs.
376.8 GNU Emacs
Cominciai a lavorare su GNU Emacs nel settembre 1984, e all’inizio del 1985 cominciava ad
essere utilizzabile. Così potei iniziare ad usare sistemi Unix per scrivere; fino ad allora, avevo
scritto sempre su altri tipi di macchine, non avendo nessun interesse ad imparare vi né ed.
A questo punto alcuni cominciarono a voler usare GNU Emacs, il che pose il problema di come
distribuirlo. Naturalmente lo misi sul server ftp anonimo del computer che usavo al MIT (questo
computer, prep.ai.mit.edu, divenne così il sito ftp primario di distribuzione di GNU; quando
alcuni anni dopo andò fuori servizio, trasferimmo il nome sul nostro nuovo ftp server). Ma allora
molte delle persone interessate non erano su Internet e non potevano ottenere una copia via ftp,
così mi si pose il problema di cosa dir loro.
Avrei potuto dire: «trova un amico che è in rete disposto a farti una copia». Oppure avrei potuto
fare quel che feci con l’originario Emacs su PDP-10, e cioè dir loro: «spediscimi una busta
affrancata ed un nastro, ed io te lo rispedisco con sopra Emacs». Ma ero senza lavoro, e cercavo
un modo di far soldi con il software libero. E così feci sapere che avrei spedito un nastro a chi lo
Il progetto GNU
4307
voleva per 150 dollari. In questo modo, creai un’impresa di distribuzione di software libero, che
anticipava le compagnie che oggi distribuiscono interi sistemi GNU basati su Linux.
376.9 Un programma è libero per tutti?
Se un programma è software libero quando esce dalle mani del suo autore, non significa necessariamente che sarà software libero per chiunque ne abbia una copia. Per esempio, il software
di pubblico dominio (software senza copyright) è software libero, ma chiunque può farne una
versione modificata proprietaria. Analogamente, molti programmi liberi sono protetti da diritto
d’autore, ma vengono distribuiti con semplici licenze permissive che permettono di farne versioni
modificate proprietarie.
L’esempio emblematico della questione è l’X Window System. Sviluppato al MIT, e pubblicato
come software libero con una licenza permissiva, fu rapidamente adottato da diverse società informatiche. Queste aggiunsero X ai loro sistemi Unix proprietari, solo in forma binaria, e coperto
dello stesso accordo di non-diffusione. Queste copie di X non erano software più libero di quanto
lo fosse Unix.
Gli autori dell’X Window System non ritenevano che questo fosse un problema, anzi se lo aspettavano ed era loro intenzione che accadesse. Il loro scopo non era la libertà, ma semplicemente
il "successo", definito come "avere tanti utenti". Non erano interessati che questi utenti fossero
liberi, ma solo che fossero numerosi.
Questo sfociò in una situazione paradossale, in cui due modi diversi di misurare la quantità di
libertà risultavano in risposte diverse alla domanda «questo programma è libero»? Giudicando
sulla base della libertà offerta dai termini distributivi usati dal MIT, si sarebbe dovuto dire che X
era software libero. Ma misurando la libertà dell’utente medio di X, si sarebbe dovuto dire che
X era software proprietario. La maggior parte degli utenti di X usavano le versioni proprietarie
fornite con i sistemi Unix, non la versione libera.
376.10 Il permesso d’autore (copyleft) e la GNU GPL
Lo scopo di GNU consisteva nell’offrire libertà agli utenti, non solo nell’ottenere ampia diffusione. Avevamo quindi bisogno di termini di distribuzione che evitassero che il software GNU fosse
trasformato in software proprietario. Il metodo che usammo si chiama "permesso d’autore".
4
Il permesso d’autore (copyleft)5 usa le leggi sul diritto d’autore (copyright), ma le capovolge per
ottenere lo scopo opposto: invece che un metodo per privatizzare il software, diventa infatti un
mezzo per mantenerlo libero.
Il succo dell’idea di permesso d’autore consiste nel dare a chiunque il permesso di eseguire il programma, copiare il programma, modificare il programma, e distribuirne versioni modificate, ma
senza dare il permesso di aggiungere restrizioni. In tal modo, le libertà essenziali che definiscono
il "free software" (software libero) sono garantite a chiunque ne abbia una copia, e diventano
diritti inalienabili.
Perché un permesso d’autore sia efficace, anche le versioni modificate devono essere libere. Ciò
assicura che ogni lavoro basato sul nostro sia reso disponibile per la nostra comunità, se pubblicato. Quando dei programmatori professionisti lavorano su software GNU come volontari, è
4
Nel 1984 o 1985, Don Hopkins, persona molto creativa, mi mandò una lettera. Sulla busta aveva scritto diverse
frasi argute, fra cui questa: "Permesso d’autore--tutti i diritti rovesciati". Utilizzai l’espressione "permesso d’autore" per
battezzare il concetto di distribuzione che allora andavo elaborando.
5
[NdT: si tratta di un gioco di parole, che qui viene reso con "permesso di autore": copyright (diritto di autore) è
formato dalle parola "copy" (copia) e "right" (diritto, ma anche destra), opposto di "left" (sinistra, ma anche lasciato).]
4308
Il progetto GNU
il permesso d’autore che impedisce ai loro datori di lavoro di dire: «non puoi distribuire quei
cambiamenti, perché abbiamo intenzione di usarli per creare la nostra versione proprietaria del
programma».
La clausola che i cambiamenti debbano essere liberi è essenziale se vogliamo garantire libertà
a tutti gli utenti del programma. Le aziende che privatizzarono l’X Window System di solito
avevano apportato qualche modifica per per portare il programma sui loro sistemi e sulle loro
macchine. Si trattava di modifiche piccole rispetto alla mole di X, ma non banali. Se apportare
modifiche fosse una scusa per negare libertà agli utenti, sarebbe facile per chiunque approfittare
di questa scusa.
Una problematica correlata è quella della combinazione di un programma libero con codice non
libero. Una tale combinazione sarebbe inevitabilmente non libera; ogni libertà che manchi dalla
parte non libera mancherebbe anche dall’intero programma. Permettere tali combinazioni aprirebbe non uno spiraglio, ma un buco grosso come una casa. Quindi un requisito essenziale per il
permesso d’autore è tappare il buco: tutto ciò che venga aggiunto o combinato con un programma
protetto da permesso d’autore dev’essere tale che il programma risultante sia anch’esso libero e
protetto da permesso d’autore.
La specifica implementazione di permesso d’autore che utilizziamo per la maggior parte del
software GNU è la GNU General Public License (licenza pubblica generica GNU), abbreviata in
GNU GPL. Abbiamo altri tipi di permesso d’autore che sono utilizzati in circostanze specifiche.
I manuali GNU sono anch’essi protetti da permesso d’autore, ma ne usano una versione molto
più semplice, perché per i manuali non è necessaria la complessità della GPL.
376.11 La Free Software Foundation
Man mano che l’interesse per Emacs aumentava, altre persone parteciparono al progetto GNU,
e decidemmo che era di nuovo ora di cercare finanziamenti. Così nel 1985 fondammo la Free
Software Foundation (Fondazione per il software libero), una organizzazione senza fini di lucro
per lo sviluppo di software libero. La FSF fra l’altro si prese carico della distribuzione dei nastri
di Emacs; più tardi estese l’attività aggiungendo sul nastro altro software libero (sia GNU che
non GNU) e vendendo manuali liberi.
La FSF accetta donazioni, ma gran parte delle sue entrate è sempre stata costituita dalle vendite:
copie di software libero e servizi correlati. Oggi vende CD-ROM di codice sorgente, CD-ROM
di programmi compilati, manuali stampati professionalmente (tutti con libertà di ridistribuzione
e modifica), e distribuzioni Deluxe (nelle quali compiliamo l’intera scelta di software per una
piattaforma a richiesta).
I dipendenti della Free Software Foundation hanno scritto e curato la manutenzione di diversi
pacchetti GNU. Fra questi spiccano la libreria C e la shell. La libreria C di GNU è utilizzata da
ogni programma che gira su sistemi GNU/Linux per comunicare con Linux. È stata sviluppata da
un membro della squadra della Free Software Foundation, Roland McGrath. La shell usata sulla
maggior parte dei sistemi GNU/Linux è Bash, la Bourne Again Shell6 , che è stata sviluppata da
Brian Fox, dipendente della FSF.
Finanziammo lo sviluppo di questi programmi perché il progetto GNU non riguardava solo strumenti di lavoro o un ambiente di sviluppo: il nostro obiettivo era un sistema operativo completo,
e questi programmi erano necessari per raggiungere quell’obiettivo.
6
"Bourne Again Shell" è un gioco di parole sul nome "Bourne Shell", che era la normale shell di Unix [NdT: "Bourne
again" richiama l’espressione cristiana "born again", "rinato" (in Cristo)].
Il progetto GNU
4309
376.12 Il supporto per il software libero
La filosofia del software libero rigetta una diffusa pratica commerciale in particolare, ma non
è contro il commercio. Quando un’impresa rispetta la libertà dell’utente, c’è da augurarle ogni
successo.
La vendita di copie di Emacs esemplifica un modo di condurre affari col software libero. Quando
la FSF prese in carico quest’attività, dovetti trovare un’altra fonte di sostentamento. La trovai
nella vendita di servizi relativi al software libero che avevo sviluppato, come insegnare argomenti quali programmazione di Emacs e personalizzazione di GCC, oppure sviluppare software,
soprattutto adattamento di GCC a nuove architetture.
Oggi tutte queste attività collegate al software libero sono esercitate da svariate aziende. Alcune
distribuiscono raccolte di software libero su CD-ROM, altre offrono consulenza a diversi livelli,
dall’aiutare gli utenti in difficoltà, alla correzione di errori, all’aggiunta di funzionalità non banali.
Si cominciano anche a vedere aziende di software che si fondano sul lancio di nuovi programmi
liberi.
Attenzione, però: diverse aziende che si fregiano del marchio "open source" (software aperto) in
realtà fondano le loro attività su software non libero che funziona insieme con software libero.
Queste non sono aziende di software libero, sono aziende di software proprietario i cui prodotti
attirano gli utenti lontano dalla libertà. Loro li chiamano "a valore aggiunto", il che riflette i valori
che a loro farebbe comodo che adottassimo: la convenienza prima della libertà. Se noi riteniamo
che la libertà abbia più valore, li dovremmo chiamare prodotti "a libertà sottratta".
376.13 Obiettivi tecnici
L’obiettivo principale di GNU era essere software libero. Anche se GNU non avesse avuto alcun
vantaggio tecnico su Unix, avrebbe avuto sia un vantaggio sociale, permettendo agli utenti di
cooperare, sia un vantaggio etico, rispettando la loro libertà.
Tuttavia risultò naturale applicare al lavoro le regole classiche di buona programmazione;
per esempio, allocare le strutture dati dinamicamente per evitare limitazioni arbitrarie sulla
dimensione dei dati, o gestire tutti i possibili codici a 8 bit in tutti i casi ragionevoli.
Inoltre, al contrario di Unix che era pensato per piccole dimensioni di memoria, decidemmo di
non supportare le macchine a 16 bit (era chiaro che le macchine a 32 bit sarebbero state la norma
quando il sistema GNU sarebbe stato completo), e di non preoccuparci di ridurre l’occupazione
di memoria a meno che eccedesse il megabyte. In programmi per i quali non era essenziale la
gestione di file molto grandi, spingemmo i programmatori a leggere in memoria l’intero file di
ingresso per poi analizzare il file senza doversi preoccupare delle operazioni di I/O.
Queste decisioni fecero sì che molti programmi GNU superassero i loro equivalenti Unix sia in
affidabilità che in velocità di esecuzione.
376.14 Donazioni di computer
Man mano che la reputazione del progetto GNU andava crescendo, alcune persone iniziarono
a donare macchine su cui girava Unix. Queste macchine erano molto utili, perché il modo più
semplice di sviluppare componenti per GNU era di farlo su di un sistema Unix così da sostituire pezzo per pezzo i componenti di quel sistema. Ma queste macchine sollevavano anche una
questione etica: se fosse giusto per noi anche solo possedere una copia di Unix.
Unix era (ed è) software proprietario, e la filosofia del progetto GNU diceva che non avremmo
dovuto usare software proprietario. Ma, applicando lo stesso ragionamento per cui la violenza
4310
Il progetto GNU
è ammessa per autodifesa, conclusi che fosse legittimo usare un pacchetto proprietario, se ciò
fosse stato importante nel crearne un sostituto libero che permettesse ad altri di smettere di usare
quello proprietario.
Tuttavia, benchè fosse un male giustificabile, era pur sempre un male. Oggi non abbiamo più
alcuna copia di Unix, perché le abbiamo sostituite con sistemi operativi liberi. Quando non fu
possibile sostituire il sistema operativo di una macchina con uno libero, sostituimmo la macchina.
376.15 L’elenco dei compiti GNU
Mentre il progetto GNU avanzava, ed un numero sempre maggiore di componenti di sistema
venivano trovati o sviluppati, diventò utile stilare un elenco delle parti ancora mancanti. Usammo
questo elenco per ingaggiare programmatori che scrivessero tali parti, e l’elenco prese il nome
di elenco dei compiti GNU. In aggiunta ai componenti Unix mancanti inserimmo nell’elenco
svariati progetti utili di programmazione o di documentazione che a nostro parere non dovrebbero
mancare in un sistema operativo veramente completo.
Oggi non compare quasi nessun componente Unix nell’elenco dei compiti GNU; tutti questi
lavori, a parte qualcuno non essenziale, sono già stati svolti. D’altro canto l’elenco è pieno di
quei progetti che qualcuno chiamerebbe "applicazioni": ogni programma che interessi ad una
fetta non trascurabile di utenti sarebbe un’utile aggiunta ad un sistema operativo.
L’elenco comprende anche dei giochi, e così è stato fin dall’inizio: Unix comprendeva dei giochi,
perciò era naturale che così fosse anche per GNU. Ma poiché non c’erano esigenze di compatibilità per i giochi, non ci attenemmo alla scelta di giochi presenti in Unix, preferendo piuttosto
fornire un elenco di diversi tipi di giochi potenzialmente graditi agli utenti.
376.16 La licenza GNU per le librerie
La libreria C del sistema GNU utilizza un tipo speciale di permesso d’autore, la "Licenza Pubblica GNU per le Librerie"7 , che permette l’uso della libreria da parte di software proprietario.
Perché quest’eccezione?
Non si tratta di questioni di principio: non c’è nessun principio che dica che i prodotti software proprietari abbiano il diritto di includere il nostro codice (perché contribuire ad un progetto
fondato sul rifiuto di condividere con noi?). L’uso della licenza LGPL per la libreria C, o per
qualsiasi altra libreria, è una questione di strategia.
La libreria C svolge una funzione generica: ogni sistema operativo proprietario ed ogni compilatore includono una libreria C. Di conseguenza, rendere disponibile la nostra libreria C solo
per i programmi liberi non avrebbe dato nessun vantaggio a tali programmi liberi, avrebbe solo
disincentivato l’uso della nostra libreria.
C’è un’eccezione a questa situazione: sul sistema GNU (termine che include GNU/Linux) l’unica
libreria C disponibile è quella GNU. Quindi i termini di distribuzione della nostra libreria C
determinano se sia possibile o meno compilare un programma proprietario per il sistema GNU.
Non ci sono ragioni etiche per permettere l’uso di applicazioni proprietarie sul sistema GNU, ma
strategicamente sembra che impedirne l’uso servirebbe più a scoraggiare l’uso del sistema GNU
che non a incoraggiare lo sviluppo di applicazioni libere.
Ecco perché l’uso della licenza LGPL è una buona scelta strategica per la libreria C, mentre per
le altre librerie la strategia va valutata caso per caso. Quando una libreria svolge una funzione
7
[NdT: nel 1999 la FSF ha cambiato nome alla licenza LGPL che ora si chiama "Lesser GPL", GPL attenuata, per
non suggerire che si tratti della forma di licenza preferenziale per le librerie.]
Il progetto GNU
4311
particolare che può aiutare a scrivere certi tipi di programmi, distribuirla secondo la GPL, quindi
limitandone l’uso ai soli programmi liberi, è un modo per aiutare gli altri autori di software libero,
dando loro un vantaggio nei confronti del software proprietario.
Prendiamo come esempio GNU-Readline, una libreria scritta per fornire a Bash la modificabilità
della linea di comando: Readline è distribuita secondo la normale licenza GPL, non la LGPL. Ciò
probabilmente riduce l’uso di Readline, ma questo non rappresenta una perdita per noi; d’altra
parte almeno una applicazione utile è stata resa software libero proprio al fine di usare Readline,
e questo è un guadagno tangibile per la comunità.
Chi sviluppa software proprietario ha vantaggi economici, gli autori di programmi liberi hanno
bisogno di avvantaggiarsi a vicenda. Spero che un giorno possiamo avere una grande raccolta di
librerie coperte dalla licenza GPL senza che esista una raccolta equivalente per chi scrive software
proprietario. Tale libreria fornirebbe utili moduli da usare come i mattoni per costruire nuovi
programmi liberi, e costituendo un sostanziale vantaggio per la scrittura di ulteriori programmi
liberi.
376.17 Togliersi il prurito?
Eric Raymond afferma che «ogni buon programma nasce dall’iniziativa di un programmatore
che si vuole togliere un suo personale prurito». È probabile che talvolta succeda così, ma molte
parti essenziali del software GNU sono state sviluppate al fine di completare un sistema operativo
libero. Derivano quindi da una idea e da un progetto, non da una necessità contingente.
Per esempio, abbiamo sviluppato la libreria C di GNU perché un sistema di tipo Unix ha bisogno
di una libreria C, la Bourne-Again Shell (bash) perché un sistema di tipo Unix ha bisogno di una
shell, e GNU tar perché un sistema di tipo Unix ha bisogno un programma tar. Lo stesso vale per
i miei programmi: il compilatore GNU, GNU Emacs, GDB, GNU Make.
Alcuni programmi GNU sono stati sviluppati per fronteggiare specifiche minacce alla nostra
libertà: ecco perché abbiamo sviluppato gzip come sostituto per il programma Compress, che la
comunità aveva perduto a causa dei brevetti sull’algoritmo LZW. Abbiamo trovato persone che
sviluppassero LessTif, e più recentemente abbiamo dato vita ai progetti GNOME e Harmony per
affrontare i problemi causati da alcune librerie proprietarie (come descritto più avanti). Stiamo
sviluppando la GNU Privacy Guard per sostituire i diffusi programmi di crittografia non liberi,
perché gli utenti non siano costretti a scegliere tra riservatezza e libertà.
Naturalmente, i redattori di questi programmi sono coinvolti nel loro lavoro, e varie persone
vi hanno aggiunto diverse funzionalità secondo le loro personali necessità ed i loro interessi.
Tuttavia non è questa la ragione dell’esistenza di tali programmi.
376.18 Sviluppi inattesi
All’inizio del progetto GNU pensavo che avremmo sviluppato l’intero sistema GNU e poi lo
avremmo reso disponibile tutto insieme, ma le cose non andarono così.
Poiché i componenti del sistema GNU sono stati implementati su un sistema Unix, ognuno di
essi poteva girare su sistemi Unix molto prima che esistesse un sistema GNU completo. Alcuni
di questi programmi divennero diffusi e gli utenti iniziarono ad estenderli e a renderli utilizzabili
su nuovi sistemi: sulle varie versioni di Unix, incompatibili tra loro, e talvolta anche su altri
sistemi.
Questo processo rese tali programmi molto più potenti e attirò finanziamenti e collaboratori al
progetto GNU; tuttavia probabilmente ritardò di alcuni anni la realizzazione di un sistema minimo funzionante, perché il tempo degli autori GNU veniva impiegato a curare la compatibilità di
4312
Il progetto GNU
questi programmi con altri sistemi e ad aggiungere nuove funzionalità ai componenti esistenti,
piuttosto che a proseguire nella scrittura di nuovi componenti.
376.19 GNU-Hurd
Nel 1990 il sistema GNU era quasi completo, l’unica parte significativa ancora mancante era il
kernel. Avevamo deciso di implementare il nostro kernel come un gruppo di processi server che
girassero sul sistema Mach. Mach è un microkernel sviluppato alla Carnegie Mellon University
e successivamente all’Università dello Utah; GNU Hurd è un gruppo di server (o "herd of gnus":
mandria di gnu) che gira su Mach svolgendo le funzioni del kernel Unix. L’inizio dello sviluppo
fu ritardato nell’attesa che Mach fosse reso disponibile come software libero, come era stato
promesso.
Una ragione di questa scelta progettuale fu di evitare quella che sembrava la parte più complessa
del lavoro: effettuare il debugging del kernel senza un debugger a livello sorgente. Questo lavoro
era già stato fatto, appunto in Mach, e avevamo previsto di effettuare il debugging dei server
Hurd come programmi utente, con GDB. Ma questa fase si rivelò molto lunga, ed il debugging
dei server multi-thread che si scambiano messaggi si è rivelato estremamente complesso. Per
rendere Hurd robusto furono così necessari molti anni.
376.20 Alix
Originariamente il kernel GNU non avrebbe dovuto chiamarsi Hurd; il suo nome originale era
Alix, come la donna di cui ero innamorato in quel periodo. Alix, che era amministratrice di
sistemi Unix, aveva sottolineato come il suo nome corrispondesse ad un comune schema usato per
battezzare le versioni del sistema Unix: scherzosamente diceva ai suoi amici: «qualcuno dovrebbe
chiamare un kernel come me». Io non dissi nulla ma decisi di farle una sorpresa scrivendo un
kernel chiamato Alix.
Le cose non andarono così. Michael Bushnell (ora Thomas), principale autore del kernel, preferì
il nome Hurd, e chiamò Alix una parte del kernel, quella che serviva a intercettare le chiamate di
sistema e a gestirle inviando messaggi ai server che compongono HURD.
Infine io e Alix ci lasciammo e lei cambiò nome; contemporaneamente la struttura di Hurd veniva
cambiata in modo che la libreria C mandasse messaggi direttamente ai server, e così il componente Alix scomparve dal progetto. Prima che questo accadesse, però, un amico di Alix si accorse
della presenza del suo nome nel codice sorgente di Hurd e glielo disse. Così il nome raggiunse il
suo scopo.
376.21 Linux e GNU/Linux
GNU Hurd non è pronto per un uso non sperimentale, ma per fortuna è disponibile un altro
kernel: nel 1991 Linus Torvalds sviluppò un Kernel compatibile con Unix e lo chiamò Linux.
Attorno al 1992, la combinazione di Linux con il sistema GNU ancora incompleto produsse un
sistema operativo libero completo (naturalmente combinarli fu un notevole lavoro di per sé). È
grazie a Linux che oggi possiamo utilizzare una versione del sistema GNU.
Chiamiamo GNU/Linux questa versione del sistema, per indicare la sua composizione come una
combinazione del sistema GNU col kernel Linux.
Il progetto GNU
4313
376.22 Le sfide che ci aspettano
Abbiamo dimostrato la nostra capacità di sviluppare un’ampia gamma di software libero, ma
questo non significa che siamo invincibili e inarrestabili. Diverse sfide rendono incerto il futuro
del software libero, e affrontarle richiederà perseveranza e sforzi costanti, talvolta per anni. Sarà necessaria quella determinazione che le persone sanno dimostrare quando danno valore alla
propria libertà e non permettono a nessuno di sottrargliela. Le quattro sezioni seguenti parlano di
queste sfide.
376.23 Hardware segreto
Sempre più spesso, i costruttori di hardware tendono a mantenere segrete le specifiche delle
loro apparecchiature; questo rende difficile la scrittura di driver liberi che permettano a Linux e
XFree86 di supportare nuove periferiche. Anche se oggi abbiamo sistemi completamente liberi,
potremmo non averli domani se non saremo in grado di supportare i calcolatori di domani.
Esistono due modi per affrontare il problema. Un programmatore può ricostruire le specifiche
dell’hardware usando tecniche di reverse engineering. Oppure si può scegliere hardware supportato dai programmi liberi: man mano che il nostro numero aumenta, la segretezza delle specifiche
diventerà una pratica controproducente.
Il reverse engineering è difficile: avremo programmatori sufficientemente determinati da dedicarvisi? Sì, se avremo costruito una forte consapevolezza che avere programmi liberi sia una
questione di principio e che i driver non liberi non sono accettabili. E succederà che molti di noi
accettino di spendere un po’ di più o perdere un po’ più di tempo per poter usare driver liberi?
Sì, se il desiderio di libertà e la determinazione ad ottenerla saranno diffusi.
376.24 Librerie non libere
Una libreria non libera che giri su sistemi operativi liberi funziona come una trappola per i creatori di programmi liberi. Le funzionalità attraenti della libreria fungono da esca; chi usa la libreria
cade nella trappola, perché il programma che crea è inutile come parte di un sistema operativo
libero (a rigore, il programma potrebbe esservi incluso, ma non funzionerebbe, visto che manca
la libreria). Peggio ancora, se un programma che usa la libreria proprietaria diventa diffuso, può
attirare altri ignari programmatori nella trappola.
Il problema si concretizzò per la prima volta con la libreria Motif, negli anni ’80. Sebbene non
ci fossero ancora sistemi operativi liberi, i problemi che Motif avrebbe causato loro erano già
chiari. Il progetto GNU reagì in due modi: interessandosi presso diversi progetti di software
libero perché supportassero gli strumenti grafici X liberi in aggiunta a Motif, e cercando qualcuno
che scrivesse un sostituto libero di Motif. Il lavoro richiese molti anni: solo nel 1997 LessTif,
sviluppato dagli "Hungry Programmers", divenne abbastanza potente da supportare la maggior
parte delle applicazioni Motif.
Tra il 1996 e il 1998 un’altra libreria non libera di strumenti grafici, chiamata Qt, veniva usata in
una significativa raccolta di software libero: l’ambiente grafico KDE.
I sistemi liberi GNU/Linux non potevano usare KDE, perché non potevamo usare la libreria;
tuttavia, alcuni distributori commerciali di sistemi GNU/Linux, non scrupolosi nell’attenersi solo
ai programmi liberi, aggiunsero KDE ai loro sistemi, ottenendo così sistemi che offrivano più
funzionalità, ma meno libertà. Il gruppo che sviluppava KDE incoraggiava esplicitamente altri
programmatori ad usare Qt, e milioni di nuovi "utenti Linux" non sospettavano minimamente che
questo potesse costituire un problema. La situazione si faceva pericolosa.
4314
Il progetto GNU
La comunità del software libero affrontò il problema in due modi: GNOME e Harmony.
GNOME (GNU Network Object Model Environment, modello di ambiente per oggetti di rete)
è il progetto GNU per l’ambiente grafico (desktop). Intrapreso nel 1997 da Miguel de Icaza e
sviluppato con il supporto di Red Hat Software, GNOME si ripromise di fornire funzionalità
grafiche simili a quelle di KDE, ma usando esclusivamente software libero. GNOME offre anche
dei vantaggi tecnici, come il supporto per svariati linguaggi di programmazione, non solo il C++.
Ma il suo scopo principale era la libertà: non richiedere l’uso di alcun programma che non fosse
libero.
Harmony è una libreria compatibile con Qt, progettata per rendere possibile l’uso del software
KDE senza dover usare Qt.
Nel novembre 1998 gli autori di Qt annunciarono un cambiamento di licenza che, una volta
operativo, avrebbe reso Qt software libero. Non c’è modo di esserne certi, ma credo che questo
fu in parte dovuto alla decisa risposta della comunità al problema posto da Qt quando non era
libero (la nuova licenza è scomoda ed iniqua, per cui rimane comunque preferibile evitare l’uso
di Qt).
Come risponderemo alla prossima allettante libreria non libera? Riuscirà la comunità in toto a
comprendere l’importanza di evitare la trappola? Oppure molti di noi preferiranno la convenienza
alla libertà, creando così ancora un grave problema? Il nostro futuro dipende dalla nostra filosofia.
376.25 Brevetti sul software
Il maggior pericolo a cui ci troviamo di fronte è quello dei brevetti sul software, che possono
rendere inaccessibili al software libero algoritmi e funzionalità per un tempo che può estendersi
fino a vent’anni. I brevetti sugli algoritmi di compressione LZW furono depositati nel 1983, e
ancor oggi non possiamo distribuire programmi liberi che producano immagini GIF compresse.
Nel 1998 un programma libero per produrre audio compresso MP3 venne ritirato sotto minaccia
di una causa per violazione di brevetto.
Ci sono modi per affrontare la questione brevetti: possiamo cercare prove che un brevetto non sia
valido oppure possiamo cercare modi alternativi per ottenere lo stesso risultato. Ognuna di queste
tecniche, però, funziona solo in certe circostanze; quando entrambe falliscono un brevetto può
obbligare tutto il software libero a rinunciare a qualche funzionalità che gli utenti desiderano.
Cosa dobbiamo fare quando ciò accade?
Chi fra noi apprezza il software libero per il valore della libertà rimarrà comunque dalla parte dei
programmi liberi; saremo in grado di svolgere il nostro lavoro senza le funzionalità coperte da
brevetto. Ma coloro che apprezzano il software libero perché si aspettano che sia tecnicamente
superiore probabilmente grideranno al fallimento quando un brevetto ne impedisce lo sviluppo.
Perciò, nonostante sia utile parlare dell’efficacia pratica del modello di sviluppo "a cattedrale",
e dell’affidabilità e della potenza di un dato programma libero, non ci dobbiamo fermare qui;
dobbiamo parlare di libertà e di principi.
376.26 Documentazione libera
La più grande carenza nei nostri sistemi operativi liberi non è nel software, quanto nella carenza di buoni manuali liberi da includere nei nostri sistemi. La documentazione è una parte
essenziale di qualunque pacchetto software; quando un importante pacchetto software libero non
viene accompagnato da un buon manuale libero si tratta di una grossa lacuna. E di queste lacune
attualmente ne abbiamo molte.
Il progetto GNU
4315
La documentazione libera, come il software libero, è una questione di libertà, non di prezzo. Il
criterio per definire libero un manuale è fondamentalmente lo stesso che per definire libero un
programma: si tratta di offrire certe libertà a tutti gli utenti. Deve essere permessa la redistribuzione (compresa la vendita commerciale), sia in formato elettronico che cartaceo, in modo che il
manuale possa accompagnare ogni copia del programma.
Autorizzare la modifica è anch’esso un aspetto cruciale; in generale, non credo sia essenziale
permettere alle persone di modificare articoli e libri di qualsiasi tipo. Per esempio, non credo che
voi o io dobbiamo sentirci in dovere di autorizzare la modifica di articoli come questo, articoli
che descrivono le nostre azioni e il nostro punto di vista.
Ma c’è una ragione particolare per cui la libertà di modifica è cruciale per la documentazione
dei programmi liberi. Quando qualcuno esercita il proprio diritto di modificare il programma,
aumentandone o alterandone le funzionalità, se è coscienzioso modificherà anche il manuale,
in modo da poter fornire una documentazione utile e accurata insieme al programma modificato.
Un manuale che non permetta ai programmatori di essere coscienziosi e completare il loro lavoro
non soddisfa i bisogni della nostra comunità.
Alcuni limiti sulla modificabilità non pongono alcun problema; per esempio, le richieste di conservare la nota di copyright dell’autore originale, i termini di distribuzione e la lista degli autori
vanno bene. Non ci sono problemi nemmeno nel richiedere che le versioni modificate dichiarino
esplicitamente di essere tali, così pure che intere sezioni non possano essere rimosse o modificate, finché queste sezioni vertono su questioni non tecniche. Restrizioni di questo tipo non creano
problemi perché non impediscono al programmatore coscienzioso di adattare il manuale perché
rispecchi il programma modificato. In altre parole, non impediscono alla comunità del software
libero di beneficiare appieno dal manuale.
D’altro canto, deve essere possibile modificare tutto il contenuto tecnico del manuale e poter
distribuire il risultato in tutti i formati usuali, attraverso tutti i normali canali di distribuzione;
diversamente, le restrizioni creerebbero un ostacolo per la comunità, il manuale non sarebbe
libero e avremmo bisogno di un altro manuale.
Gli sviluppatori di software libero avranno la consapevolezza e la determinazione necessarie a
produrre un’intera gamma di manuali liberi? Ancora una volta, il nostro futuro dipende dalla
nostra filosofia.
376.27 Dobbiamo parlare di libertà
Stime recenti valutano in dieci milioni il numero di utenti di sistemi GNU/Linux quali Debian
GNU/Linux e Red Hat Linux. Il software libero ha creato tali vantaggi pratici che gli utenti
stanno approdando ad esso per pure ragioni pratiche.
Gli effetti positivi di questa situazione sono evidenti: maggior interesse a sviluppare software
libero, più clienti per le imprese di software libero e una migliore capacità di incoraggiare le
aziende a sviluppare software commerciale libero invece che prodotti software proprietari.
L’interesse per il software, però, sta crescendo più in fretta della coscienza della filosofia su cui è
basato, e questa disparità causa problemi. La nostra capacità di fronteggiare le sfide e le minacce
descritte in precedenza dipende dalla determinazione nell’essere impegnati per la libertà. Per
essere sicuri che la nostra comunità abbia tale determinazione, dobbiamo diffondere l’idea presso
i nuovi utenti man mano che entrano a far parte della comunità.
Ma in questo stiamo fallendo: gli sforzi per attrarre nuovi utenti nella comunità sono di gran lunga
maggiori degli sforzi per l’educazione civica della comunità stessa. Dobbiamo fare entrambe le
cose, e dobbiamo mantenere un equilibrio fra i due impegni.
4316
Il progetto GNU
376.28 "Open Source"
Parlare di libertà ai nuovi utenti è diventato più difficile dal 1998, quando una parte della
comunità decise di smettere di usare il termine "free software" e usare al suo posto "open source".
Alcune delle persone che suggerirono questo termine intendevano evitare che si confondesse
"free" con "gratis", un valido obiettivo. D’altra parte, altre persone intendevano mettere da parte
lo spirito del principio che aveva dato la spinta al movimento del software libero e al progetto
GNU, puntando invece ad attrarre i dirigenti e gli utenti commerciali, molti dei quali afferiscono
ad una ideologia che pone il profitto al di sopra della libertà, della comunità, dei principi. Perciò la
retorica di "open source" si focalizza sul possibilità di creare software di buona qualità e potente
ma evita deliberatamente le idee di libertà, comunità, principio.
Le riviste che si chiamano "Linux..." sono un chiaro esempio di ciò: sono piene di pubblicità di
software proprietario che gira sotto GNU/Linux; quando ci sarà il prossimo Motif o Qt, queste
riviste avvertiranno i programmatori di starne lontano o accetteranno la sua pubblicità?
L’appoggio delle aziende può contribuire alla comunità in molti modi; a parità di tutto il resto è
una cosa utile. Ma ottenere questo appoggio parlando ancor meno di libertà e principi può essere
disastroso; rende ancora peggiore lo sbilanciamento descritto tra diffusione ed educazione civica.
"Software libero" (free software) e "sorgente aperto" (open source) descrivono più o meno la
stessa categoria di software, ma dicono cose differenti sul software e sui valori. Il progetto GNU
continua ad usare il termine "software libero" per esprimere l’idea che la libertà sia importante,
non solo la tecnologia.
376.29 Prova!
La filosofia di Yoda ("Non c’è provare") suona bene, ma per me non funziona. Ho fatto la maggior
parte del mio lavoro angustiato dal timore di non essere in grado di svolgere il mio compito e nel
dubbio, se fossi riuscito, che non fosse sufficiente per raggiungere l’obiettivo. Ma ci ho provato
in ogni caso perché nessuno tranne me si poneva tra il nemico e la mia città. Sorprendendo me
stesso, qualche volta sono riuscito.
A volte ho fallito, alcune delle mie città sono cadute; poi ho trovato un’altra città minacciata e
mi sono preparato ad un’altra battaglia. Con l’andar del tempo ho imparato a cercare le possibili
minacce e a mettermi tra loro e la mia città, facendo appello ad altri hacker perché venissero e si
unissero a me.
Oggigiorno spesso non sono da solo. È un sollievo ed una gioia quando vedo un reggimento di
hacker che scavano trincee per difendere il confine e quando mi rendo conto che questa città
può sopravvivere; per ora. Ma i pericoli diventano più grandi ogni anno, ed ora Microsoft ha
esplicitamente preso di mira la nostra comunità. Non possiamo dare per scontato il futuro della
libertà; non diamolo per scontato! Se volete mantenere la vostra libertà dovete essere pronti a
difenderla.
Capitolo
377
Proprietà del software
L’esistenza del software libero, soprattutto nei termini intesi dalla Free Software Foundation,
mette in discussione la fondatezza dei principi che difendono la «proprietà» del software stesso.
Su questa controversia sono state scritte tante cose, ed è difficile avere qualcosa di nuovo da dire.
In questo capitolo vengono raccolte alcune citazioni che riguardano in particolare il problema del
brevetto sul software e le conseguenze a cui può portare questa politica.
377.1 Dal copyright al brevetto e conseguenze
Il testo seguente è un estratto da Cenni di storia del software (e dell’hardware), scritto da Giulio
Mazzolini.1
L’idea che si debbano dare dei privilegi agli stampatori nasce alla fine del ’400 a
Venezia. Si danno semplicemente dei privilegi, non esiste ancora una legislazione in
merito. Non esiste nessun diritto per gli autori, forse anche perché molti libri sono riproduzioni di testi di autori antichi. L’idea è semplice, stampare un libro costa, quindi
lo stampatore deve avere una protezione che lo protegga da un altro stampatore che
intenda stampare lo stesso libro. Nel 1709 appare la prima legge sul copyright con la
costituzione della Regina Anna in Inghilterra.
I diritti dell’autore non sono ancora ben considerati, interessa maggiormente lo stampatore. Bisogna aspettare il Romanticismo e il prevalere dei diritti della persona per
trovare interesse all’autore.
Nel 1791, in piena Rivoluzione Francese, viene scritta una legge fondamentale sul
diritto d’autore, che sancisce i diritti dell’autore, legge che per la sua chiarezza è
restata in vigore in Francia sino a questo secolo. Vi si riconosce la figura dell’autore
e se ne tutelano i diritti. L’autore dell’opera possiede tutti i diritti per il semplice fatto
di esserne l’autore.
Può, se vuole, cedere alcuni o tutti i diritti a terzi con un patto esplicito. Se si tratta di
un testo, in genere i diritti sono quelli di riprodurre il testo in un libro, eventualmente
di farne delle traduzioni e poi delle ristampe. Se l’opera è un quadro, l’autore può cedere il diritto di copia dell’opera, per esempio per farne una copertina, o un manifesto.
Un autore può tutelare la sua opera anche se ha ceduto i diritti di riproduzione. Può
esigere che l’opera resti integra, che non subisca modificazioni. Hanno quindi ragione i registi che pretendono che i loro film passino senza interruzioni pubblicitarie, o
senza essere censurati in alcune scene.
Quindi se comperate un quadro, con il possesso e la proprietà legittima dello stesso,
non avete automaticamente il diritto di copiarlo. L’autore poi potrebbe impedirvi di
tenerlo in un posto che svilisca o oltraggi l’opera.
Non sempre però l’autore è certo, un’opera può essere fatta da più persone, un’opera
collettiva, quindi potrebbe non essere agevole riconoscere l’autore o gli autori o la
quota di partecipazione degli stessi all’opera.
I diritti d’autore sono ereditari, per cui gli eredi potranno godere dei vantaggi
economici derivanti dai diritti d’autore anche dopo la morte dell’autore.
[...]
In Europa a seguito del dibattito tenutosi dopo la Rivoluzione Francese, venne formata
nel 1884 a Berna l’Associazione per il Diritto d’Autore, dove viene data adeguata
protezione alla figura dell’autore.
1
Nel testo sono state apportate alcune piccole correzioni con il consenso di Giulio Mazzolini.
4317
4318
Quando il legislatore dice Autore intende «di opera artistica o assimilata». Negli USA
il concetto di copyright tende a venir esteso anche in mancanza di un’opera artistica.
Per alcuni, anche una lettera commerciale può venire considerata soggetta a copyright.
[...]
La protezione del software non è oggi data solo dalla legislazione sul copyright. Negli
USA è oramai prassi brevettare pezzi il software, algoritmi, trovate varie. È brevettato
il cestino dell’Apple, l’algoritmo di compressione usato dal programma zip, l’exor del puntatore grafico. L’IBM deposita migliaia di brevetti all’anno e così pure le
grandi case.
Oggi nessuno può seriamente pensare di scrivere del software commerciale se non ha
capitali molto grandi. Infatti deve mettere degli avvocati a tempo pieno per assistere
chi scrive, affinché non incorra in infrazioni di brevetti. Non solo, poiché è impossibile
che uno studio di avvocati conosca «tutti» i brevetti di software, c’è la certezza di
incappare in qualche azione legale fatta da terzi che ritengono lesi i loro diritti. Cause
che costano molto o si chiudono con costosi accordi. Quindi di fatto oggi tutto il
«corpus» di protezioni al software deve essere visto soprattutto come strumento di
conservazione di posizioni di monopolio o dominanti.
[...]
L’avv. Pamela Samuelson ha così voluto riassumere i sei punti principali della
rivoluzione digitale:
1. è molto facile duplicare, si fa presto, costa poco, le copie sono dei duplicati
perfetti dell’originale;
2. è facilissimo trasmettere i dati e si trasmettono quasi istantaneamente, si
trasmettono in tutto il mondo scavalcando barriere nazionali, doganali, censorie;
3. il dato digitale è malleabile, si può trasformare facilmente, si può deformare quanto si vuole, un originale ne diventa facilmente un altro deformato o
rielaborato;
4. le opere letterarie, le opere sonore, le opere grafiche, una volta messe in forma
digitale, subiscono la stessa sorte, sono indistinguibili nel supporto, non sono più
differenziate tra libro, quadro e disco, mettendo in crisi i concetti di copyright
che sono diversi se si tratta appunto di quadro, disco o libro;
5. il dato digitale è compatto, è piccolo si trasporta facilmente;
6. il dato digitale non si visita più linearmente come si fa con un libro, ma in modo
non lineare. Tutti coloro che hanno visitato un sito in Internet non hanno letto
pagina dopo pagina, ma sono saltati da una pagina ad un altro sito, creandosi
percorsi individuali di esplorazione del mondo digitale.
Ciascuna delle caratteristiche precedenti è sufficiente a causare una rottura delle dottrine esistenti sulla proprietà intellettuale. Tutte e sei assieme sicuramente costringeranno i legislatori ad una modifica radicale del concetto di copyright e di proprietà
intellettuale.
4319
377.2 Problemi legati al brevetto sul software
Nel seguito sono riportate alcune citazioni di articoli e altri documenti sul problema del brevetto
sul software.
• Bryan Pfaffenberger, The Coming Software Patent Crisis: Will Linux Survive?, Linux
Journal, 10 agosto 1999
Non puoi scrivere alcun tipo di software senza violare qualche brevetto altrui;
anche «Ciao mondo!» sarebbe in violazione. Eh sì, giacché comprende una procedura di output tramite un display a mappa di bit (sì, questa procedura è brevettata). E se i detentori di questi brevetti decidono di denunciarti, sei fregato. Non ti
sarà possibile difenderti: il costo medio di una causa processuale è di $500.000.
Se un numero sufficiente di autori open-source ricevono lettere di questo genere,
potremo dire addio a Linux.
I brevetti sono legittimi, ma solo fino a un certo punto. I fondatori della Costituzione hanno inteso bilanciare il diritto conferito da un brevetto contro il bene del
pubblico.
2
• Richard M. Stallman, Saving Europe from Software Patents, Linux Today, 16 maggio 1999
Immaginate che ogni qualvolta avete preso una decisione riguardante il software
e in particolare quando avete usato un algoritmo letto in una pubblicazione o realizzato una funzionalità richiesta dai vostri utenti, avete corso il rischio di essere
denunciati.
3
• Donald E. Knuth, Letter to the Patent Office from Professor Donald Knuth, Programming
Freedom, n. 11, febbraio 1995
Quando penso ai programmi che utilizzo quotidianamente per lavorare, mi rendo
conto che nessuno di questi esisterebbe se i brevetti sul software fossero stati
comuni negli anni 60 e 70.
Gli algoritmi sono fondamentali per il software come lo sono le parole per gli
scrittori, perché costituiscono le mattonelle con cui si costruiscono prodotti interessanti. Cosa accadrebbe se gli avvocati potessero brevettare i loro metodi di
difesa o se i giudici della Corte Suprema potessero brevettare le loro decisioni
precedenti?
Ci sono modi migliori di proteggere la proprietà intellettuale degli sviluppatori
software invece di togliere loro il diritto di utilizzare le mattonelle fondamentali
per costruire i loro prodotti.
4
• Richard M. Stallman, Patent Reform Is Not Enough, GNU’s Bullettin, vol. 1, n. 13, giugno
1992
Insegnare all’Ufficio Brevetti come esaminare meglio una domanda di brevetto
per determinarne la «novità» e l’«attività inventiva» può prevenire alcuni errori clamorosi. Non aiuterà però a eliminare il problema più grave: il fatto che si
2
<http://www.linuxjournal.com/article.php/?sid=5079>
<http://features.linuxtoday.com/news_story.php3?ltsn=1999-05-16-003-05-NW-LF>
4
<http://www.pluto.linux.it/meeting/meeting1999/atti/no-patents/brevetti/docs/knuth_letter_en.html>
3
4320
sta brevettando ogni nuova caratteristica riguardante l’uso dei computer. Anche
un programma innovativo tipicamente fa uso di dozzine di tecniche e caratteristiche che non sono nuove, ognuna delle quali è potenzialmente già brevettata.
La nostra capacità di utilizzare ogni caratteristica dipenderà dalla fortuna, e se
saremo sfortunati metà del tempo, pochi programmi sfuggiranno dal violare un
grande numero di brevetti. Navigare nel labirinto di brevetti sarà più difficile che
scrivere programmi.
5
377.3 Riferimenti
• Giulio Mazzolini, Software e copyright
• Alessandro Rubini, Verso un’etica del software
<http://www.prosa.it/philosophy/etica-sw.html>
• Protecting competition against the abuse of software patents
<http://www.freepatents.org/>
• Gordon Irlam, Examples of Software Patents
<http://www.base.com/software-patents/examples.html>
5
<http://www.gnu.org/philosophy/patent-reform-is-not-enough.html>
Capitolo
378
L’ipotesi del futuro, nel bene e nel male
di Anna Rambelli
non modificabile
Il modo di comunicare nel futuro sarà sempre più tecnologico. L’informatica è il futuro. Non serviranno più le vie telefoniche. Il telefono diventerà un sistema poco usato. Si farà tutto attraverso
la via telematica.
Il futuro dell’informatica è talmente veloce che i cambiamenti sono presenti ogni giorno. Il veicolo informativo sarà pieno di sorprese, non sempre piacevoli. La situazione diventa spiacevole
quando il mezzo di informazione è usato malamente, contro l’umanità e il benessere. Se l’essere umano saprà usare bene la tecnologia, ci saranno delle trasformazioni sorprendenti in ogni
campo, specialmente nella medicina e nelle comunicazioni cibernetiche.
La cibernetica funzionerà come funzionò a suo tempo il telegrafo senza fili di Marconi: rivoluzionerà tutti gli avvenimenti della Terra. L’uomo non sarà più in grado di sopportare i cambiamenti
così mutevoli e spesso si verificheranno delle situazioni di eccessiva confusione , o meglio dire,
eccessive distorsioni mentali che potranno influenzare i comportamenti, soprattutto dei giovani.
Il giovane vivrà la macchina come una calamita da cui non riuscirà a staccarsi. Questo è il male
della trasformazione così veloce: la mente non riuscirà a stare ai tempi.
Si potrà creare una dipendenza talmente esagerata da esasperare le situazioni e da bloccare molti
meccanismi meccanografici, per cui il commercio e gli scambi andranno in crisi e l’economia
mondiale subirà dei tracolli così gravi da lasciare l’umanità sconvolta e interdetta.
Il secolo che è appena iniziato, racchiude delle aspettative e delle speranze che l’uomo è in grado
di sviluppare. Si avvereranno delle profezie legate alle tecnologie più avanzate. Non serviranno
più i soldi, perché tutto verrà acquistato tramite le vie informatiche. Anche il negozio e il supermercato subiranno uno sconvolgimento unico, il sistema della compravendita come è improntato
ora, scomparirà in breve tempo.
La manodopera servirà a ben poco. La figura della massaia non esisterà più. Esisteranno anche le
chiamate via Internet per curare e guarire certe malattie. Non dovrai più andare tu dal medico, ma
sarà lui che entrerà nella tua casa attraverso la via telematica. Quindi, anche la figura del medico
e dell’ospedale, verrà completamente cambiata.
Il tuo bambino avrà sempre meno bisogno di essere custodito perché tu potrai visualizzarlo
sempre, in ogni istante, costantemente.
Tutto questo, però, se l’essere umano non riuscirà a usarlo bene, servirà a inaridire i rapporti
umani e a sconvolgere anche la mente umana. Tutto questo dovrà essere usato con intelligenza e
comunque sempre con un sentimento di correttezza e coscienza.
L’elaboratore allegerisce molti ostacoli, ma dall’altra parte, come già detto, può impoverire i
rapporti umani e le relazioni interpersonali. Ma l’impulso, ormai scaturito, per questo mezzo di
comunicazione, è talmente forte, talmente violento, che niente e nessuno potrà mai più fermarlo.
Il rischio che questa forza travolgente impoverisca e distrugga la mente umana è grande. Non
vorremmo che la macchina prendesse il sopravvento assoluto sulle questioni, non solo mondiali,
economiche e politiche, ma soprattutto sull’autonomia e sul libero arbitrio dell’uomo.
4321
L’ipotesi del futuro, nel bene e nel male
4322
378.1 Riferimenti
• Anna Rambelli, Abbi cura di te
<http://a2.swlibero.org/~daniele/anima/nfr/>
Indice analitico del volume
/dev/boot255, 3953
/dev/cdrom, 3858
/dev/dsp, 3858
/dev/sg*, 3858
/dev/vcsa*, 4289
/dev/vcs*, 4289
/etc/brltty.conf, 4291
/etc/brltty/, 4291
/etc/dosemu.conf, 3878
/etc/dosemu.users, 3877
/etc/exports, 3960
/etc/gpm.conf, 3997
/etc/hostname, 3999
/etc/init.d/keymaps.sh, 3996
/etc/kbd/default.kmap.gz, 3996
/etc/magicfilter/, 3998
/etc/mailname, 3999
/etc/papersize, 3999
/etc/printcap, 3998
/etc/suid.conf, 4000
/etc/xcdroast/xcdroast.conf, 3858
/tftpboot/, 3955
antiword, 3874
audio stream, 3837
Aumix, 3813
backup, 3904
Barcode, 3979
braille, 4284
catdoc, 3873
CD audio, 3846
Cdcd, 3803
CDDA, 3807
CDDB, 3806
Cdparanoia, 3809
Cdrdao, 3847
Cdrecord, 3854
chkconfig, 4019
Code 128, 3972
Code 3 of 9, 3971
Code 39, 3971
Code 39 esteso, 3972
codice a barre, 3964, 3979
configurazione: Debian, 3990
configurazione: Red Hat, 4014
copia di sicurezza, 3904
copia di sicurezza: generazioni, 3906
copia di sicurezza: livelli, 3907
dbf2pg, 3871
dbview, 3870
Dcd, 3801
4323
Debian, 3990, 4001
Debian: /etc/init.d/*, 3993
Debian: /etc/rc?.d, 3994
dischetto di emergenza, 3915
dischetto di emergenza: Slackware, 3918
diskless, 3951
DOS, 3876
DOS: APPEND, 4089
DOS: ASSIGN, 4087
DOS: ATTRIB, 4089
DOS: AUTOEXEC.BAT, 4096
DOS: BREAK, 4092
DOS: BUFFERS, 4092
DOS: CALL, 4099
DOS: CH, 4075
DOS: CHCP, 4097
DOS: CHDIR, 4075
DOS: CHKDSK, 4086
DOS: CHOICE, 4103
DOS: CLS, 4103
DOS: COMP, 4091
DOS: CONFIG.SYS, 4092
DOS: COPY, 4079
DOS: COUNTRY, 4093
DOS: DATE, 4098
DOS: DEL, 4079
DOS: DELTREE, 4089
DOS: DEVICE, 4094
DOS: DEVICEHIGH, 4094
DOS: DIR, 4078
DOS: DISKCOPY, 4086
DOS: DOS, 4094
DOS: DRIVEPARM, 4094
DOS: ECHO, 4102
DOS: ERASE, 4079
DOS: FC, 4091
DOS: FCBS, 4095
DOS: FILES, 4095
DOS: FIND, 4090
DOS: FOR, 4100
DOS: FORMAT, 4084
DOS: GOTO, 4101
DOS: GRAFTABL, 4098
DOS: IF, 4100
DOS: INSTALL, 4095
DOS: JOIN, 4088
DOS: KEYB, 4097
DOS: LABEL, 4085
DOS: LASTDRIVE, 4095
DOS: LH, 4105
DOS: LOADHIGH, 4105
DOS: MD, 4076
4324
DOS: MEM, 4106
DOS: MKDIR, 4076
DOS: MORE, 4082
DOS: MOVE, 4090
DOS: PAUSE, 4103
DOS: REM, 4102
DOS: REN, 4080
DOS: RENAME, 4080
DOS: RM, 4078
DOS: RMDIR, 4078
DOS: SET, 4080
DOS: SHELL, 4096
DOS: SHIFT, 4099
DOS: SORT, 4082
DOS: STACK, 4096
DOS: SUBST, 4088
DOS: SYS, 4087
DOS: TIME, 4098
DOS: TREE, 4091
DOS: TYPE, 4081
DOS: VERIFY, 4089
DOS: VOL, 4085
DOS: XCOPY, 4086
DOSEMU, 3876
dpkg-scanpackages, 4005, 4008
EAN: European Article Number, 3966
EAN-13, 3965
EAN-8, 3965
elaboratore senza disco, 3951
ELKS, 4064
esempio: rpmdoppi, 4029
Ethernet, 3921
file DBF, 3870
filmato, 3844
FreeAmp, 3834
Gcd, 3805
GNU: Manifesto, 4294
Gnuplot, 4110
Grip, 3810
gtcd, 3802
GTV, 3844
i25, 3976
Icecast, 3841
interfogliata due su cinque, 3976
Interleaved two of five, 3976
ISBN, 3969
Ispell, 4111
ISSN, 3970
ITF, 3976
LAME, 3827
listen, 3843
MI/X, 3884
4325
Minix, 4044
Motif, 3887
MP3, 3810, 3823, 3830, 3838
MP3blaster, 3830
MP3info, 3825
MPEG, 3844
mswordview, 3873
MS-Word: conversione, 3873, 3873, 3874
Mtools, 3882
nanoLinux, 3923
Netscape, 3896
NetStreamer, 3837
nodo senza disco, 3951
ntsysv, 4019
Perl, 4111
PlayMPEG, 3844
PLIP, 3921
recode, 3868
Red Hat, 4014, 4029
Red Hat: /etc/bashrc, 4023
Red Hat: /etc/profile, 4023
Red Hat: /etc/profile.d/, 4025
Red Hat: /etc/rc.d/init.d/*, 4017
Red Hat: /etc/rc.d/rc?.d, 4018
Red Hat: /etc/sysconfig/clock, 4022
Red Hat: /etc/sysconfig/keyboard, 4022
Red Hat: /etc/sysconfig/mouse, 4022
Red Hat: /etc/sysconfig/network, 4020
Red Hat: /etc/sysconfig/network-scripts/ifcfg-*, 4021
Red Hat: /etc/sysconfig/static-routes, 4021
Red Hat: /var/spool/lpd/*/, 4027
Red Hat: ~/.bashrc, 4023
Red Hat: ~/.bash_profile, 4023
RIFF WAV, 3809, 3810, 3818
rpmdoppi, 4029
SC, 4111
shout, 3842
Slackware, 3918
sndconfig, 3799
software proprietario, 3887
Sox, 3819
Spreadsheet Calculator, 4111
StarOffice, 3887, 3893, 3895
start-stop-daemon, 3993
stazione senza disco, 3951
stream audio, 3837
streaming video, 3844
tcd, 3802
TCD, 3802
UCC/EAN 128, 3976
UCC: Uniform Code Council, 3966
UPC-A, 3965
4326
UPC-E, 3965
update-rc.d, 3995
USS Code 128, 3972
utenti, 3944, 3946, 3998, 4025
video, 3844
Wav2cdr, 3855
Wavtools, 3818
WAV-RIFF, 3809, 3810, 3818
Winword: conversione, 3873, 3873, 3874
Word: conversione, 3873, 3873, 3874
X, 3884
Xcdrdao, 3851
xcdroast, 3858
xdos, 3882
Xmms, 3832
XV, 3898
Xwave, 3818
X-CD-Roast, 3858
X-Win32, 3886
~/.xcdroast/xcdroast.conf, 3858
4327
4328
Appunti di informatica libera 2003.01.01
Volume IX
Informazioni obsolete
4329
Appunti Linux
Copyright © 1997-2000 Daniele Giacomini
Appunti di informatica libera
Copyright © 2000-2003 Daniele Giacomini
Via Morganella Est, 21 -- I-31050 Ponzano Veneto (TV) -- daniele @ swlibero.org
Le informazioni contenute in questa opera possono essere diffuse e riutilizzate in base alle condizioni poste dalla licenza GNU General Public License, come pubblicato dalla Free Software
Foundation.
In caso di modifica dell’opera e/o di riutilizzo parziale della stessa, secondo i termini della licenza, le annotazioni riferite a queste modifiche e i riferimenti all’origine di questa opera, devono
risultare evidenti e apportate secondo modalità appropriate alle caratteristiche dell’opera stessa. In nessun caso è consentita la modifica di quanto, in modo evidente, esprime il pensiero,
l’opinione o i sentimenti del suo autore.
L’opera è priva di garanzie di qualunque tipo, come spiegato nella stessa licenza GNU General
Public License.
Queste condizioni e questo copyright si applicano all’opera nel suo complesso, salvo ove indicato
espressamente in modo diverso.
The informations contained inside this work can be spread and reused under the terms of the
GNU General Public License as published by the Free Software Foundation.
If you modify this work and/or reuse it partially, under the terms of the license, the notices about
these changes and the references about the original work, must be evidenced conforming to the
work characteristics. IN NO EVENT IS ALLOWED TO MODIFY WHAT ARE CLEARLY
THE THOUGHTS, THE OPINIONS AND/OR THE FEELINGS OF THE AUTHOR.
This work is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU General Public License for more details.
These conditions and this copyright apply to the whole work, except where clearly stated in a
different way.
Una copia della licenza GNU General Public License, versione 2, si trova nell’appendice A.
A copy of GNU General Public License, version 2, is available in appendix A.
4330
The main distribution for Appunti di informatica libera is described below. For every distribution
channel the maintainer’s name and address is also reported.
Internet
• direct reading: <http://a2.swlibero.org/>
download: <ftp://a2.swlibero.org/a2/> and <http://a2.swlibero.org/ftp/>
Michele Dalla Silvestra, mds @ swlibero.org
• direct reading: <http://appuntilinux.torino.linux.it/>
download: <ftp://ftp.torino.linux.it/appunti-linux/>
Carlo Perassi, carlo @ linux.it
• direct reading: <http://sansone.crema.unimi.it/linux/a2/HTML/>
download: <http://sansone.crema.unimi.it/linux/a2/>
Fabrizio Zeno Cornelli, zeno @ filibusta.crema.unimi.it
• direct reading: <http://www.pctime.it/servizi/appunti-linux/>
download: <http://www.pctime.it/servizi/appunti-linux/a2-prelievo/>
Franco Lazzero, PCTIME, pctime @ pctime.net
• direct reading: <http://www.a2.prosa.it/>
download: <ftp://ftp.a2.prosa.it/>
Davide Barbieri, paci @ prosa.it
• direct reading: <http://linux.pueste.it/>
download: <http://linux.pueste.it/filearea/AppuntiLinux/>
David Pisa, david @ iglu.cc.uniud.it
• direct reading: <http://www.informasiti.com/Appunti/HTML/>
download: <http://www.informasiti.com/Appunti/>
Claudio Neri, Sincro Consulting, neri.c @ sincroconsulting.com
GNU distributions
• GNU/Linux Debian <http://packages.debian.org/appunti-informatica-libera>
Massimo Dal Zotto, dz @ cs.unitn.it
Italian magazine’s CD-ROM
• inter-punto-net <http://www.interpuntonet.it>
Michele Dalla Silvestra, mds @ swlibero.org
• Internet News <http://inews.tecnet.it>
Francesco Facconi, francescofacconi @ libero.it
Fabio Ferrazzo, fabio.fr @ tiscalinet.it
• Linux Magazine <http://www.edmaster.it/prodotti/linux/ult-riv.html>
Emmanuele Somma, esomma @ ieee.org
La diffusione di questa opera è incoraggiata in base ai termini della licenza.
The spread of this work is encouraged under the terms of the license.
4331
Parte lxxxi Distribuzioni GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4333
379 Monkey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4334
380 Configurazione di una distribuzione Slackware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4336
381 Script per la gestione dei pacchetti software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4341
Parte lxxxii Informazioni varie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4353
382 Emulatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4354
383 nanoRouter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4358
384 X-ISP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4362
385 Introduzione a SMB con GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4366
386 Applicazioni multimediali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4381
387 Acua . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4386
4332
Parte lxxxi
Distribuzioni GNU/Linux
379 Monkey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4334
379.1 Installazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4334
379.2 Avvio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4334
379.3 Conclusione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4334
379.4 Installazione dei pacchetti addizionali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4335
379.5 Configurazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4335
380 Configurazione di una distribuzione Slackware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4336
380.1 Procedura di inizializzazione del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4336
380.2 Configurazione della rete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4338
380.3 Configurazione di shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4339
380.4 Utenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4339
381 Script per la gestione dei pacchetti software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4341
381.1 Un sistema per gestire le installazioni tradizionali nella distribuzione Slackware
4341
381.2 Fare da sé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4346
4333
Capitolo
379
Monkey
Monkey è una mini distribuzione realizzata da Milan Kerslager allo scopo di ottenere un sistema
in grado di gestire il TCP/IP e la grafica attraverso X. È molto limitata, ma nel suo piccolo è fatta
con cura, compresi dei piccoli accorgimenti per il riutilizzo dei file di scambio della memoria
gestiti da MS-Windows. Nella sua limitatezza è comunque estremamente semplice da installare.
Si compone di un gruppo di file compressi con ‘arj’, che costituiscono l’installazione base,
assieme ad altri in formato tar+gzip che possono essere installati successivamente se lo si ritiene
necessario. Volendo, con questi pacchetti aggiuntivi si arriva a un’installazione quasi completa.
La distribuzione Monkey è raggiungibile a partire da <http://www.ibiblio.org/pub/Linux/distributions/
e dai suoi vari siti speculari.
monkey/>
379.1 Installazione
Per installare la distribuzione Monkey occorrono almeno i file compressi denominati
‘mlinux06. ’ e il programma di estrazione ‘ARJ.EXE’. I file possono essere copiati all’interno
*
di dischetti Dos, oppure risiedere in una directory del disco fisso. Negli esempi che seguono si
suppone di avere copiato i file compressi nel disco fisso, nella directory ‘C:\INST\’.
Per prima cosa viene creata la directory ‘C:\LINUX\’ che conterrà i file della distribuzione.
C:\> MD C:\LINUX
Quindi si passa nella directory in cui sono stati copiati i file compressi e da lì vengono estratti.
C:\> CD C:\INST
C:\INST> ARJ x -v -y MLINUX06 C:\LINUX
Generalmente è tutto finito.
379.2 Avvio
L’avvio della distribuzione Monkey installata in questo modo è molto semplice: basta avviare
‘LINUX.BAT’ che si trova in ‘C:\LINUX\’.
C:\> CD C:\LINUX
C:\LINUX> LINUX.BAT
Se tutto è andato nel modo giusto, il sistema si avvia e si può accedere inizialmente come utente
‘root’, senza alcuna parola d’ordine.
379.3 Conclusione
GNU/Linux non è come il Dos, anche quando risiede fisicamente in una partizione FAT. Prima di spegnere occorre eseguire la procedura necessaria, richiamandola attraverso il comando
‘shutdown’; questo deve essere fatto con i privilegi dell’utente ‘root’.
# shutdown -h now
4334
Monkey
4335
379.4 Installazione dei pacchetti addizionali
I pacchetti addizionali sono in formato tar+gzip (‘.tgz’), ma l’installazione è automatica: basta
creare la directory ‘C:\LINUX\INSTALL\’ e copiarvi all’interno i pacchetti da installare. Al
riavvio del sistema, questi vengono installati.
379.5 Configurazione
Il sistema ottenuto dall’installazione della distribuzione Monkey non deve essere configurato.
In pratica: o funziona così com’è o non serve. Questo significa che non si può pretendere di
utilizzare questa mini distribuzione su un elaboratore che non corrisponde agli standard normali.
In pratica si presuppone che l’elaboratore disponga di:
• un microprocessore i386 o superiore;
• un disco fisso ATA utilizzato senza compressione;
• un eventuale lettore CD-ROM ATA/ATAPI;
• memoria RAM per almeno 4 Mibyte;
• un mouse seriale (compatibile Microsoft) connesso alla prima porta seriale;
• un adattatore grafico VGA per l’uso del sistema grafico X.
È in grado di individuare le schede di rete ISA più comuni: ‘3C5x9’, ‘3c59x’, ‘3c90x’,
‘NE2000/NE1000’, ‘WD80x3’.
Le limitazioni che possono essere avvertite sono l’impossibilità di gestire unità SCSI (dischi fissi
o lettori CD-ROM) e di accedere a lettori CD-ROM che utilizzano interfacce proprietarie. Per
risolvere questi problemi occorrerebbe ricompilare il kernel oppure aggiungere dei moduli.
Capitolo
380
Configurazione di una distribuzione Slackware
La distribuzione Slackware è quella che utilizza il sistema di configurazione più semplice. Spesso
si ha la necessità di modificare direttamente gli script.
380.1 Procedura di inizializzazione del sistema
Si tratta di una serie di script di shell eseguiti direttamente o indirettamente attraverso le
indicazioni contenute nel file ‘/etc/inittab’. La prima cosa da notare sono i livelli di
esecuzione:
• 0 arresto del sistema;
• 1 singolo utente;
• 3 multiutente;
• 4 multiutente con login grafico;
• 6 riavvio.
Segue l’elenco dei file e delle directory che compongono la procedura di inizializzazione del
sistema.
• ‘/etc/rc.d/’
È la directory che raccoglie gli script utilizzati nella fase di avvio del sistema e in quella di
arresto.
• ‘/etc/rc.d/rc.S’
È lo script di inizializzazione del sistema. In particolare:
– attiva lo scambio della memoria (solo sulle partizioni), in base al contenuto del file
‘/etc/fstab’;
– avvia ‘update’ per automatizzare lo scarico periodico della memoria cache dei dischi;
– avvia ‘kerneld’ per automatizzare il caricamento dei moduli del kernel;
– verifica che il file system principale sia inizialmente in sola lettura;
– se il file system principale è in sola lettura, ne esegue il controllo;
– se vengono incontrati errori, attiva una shell su di una sola console (se si esce dalla
shell, si riprende l’esecuzione dello script;
– se è il caso, rimonta il file system principale in lettura-scrittura;
– esegue il montaggio degli altri file system in base al contenuto di ‘/etc/fstab’,
esclusi eventuali file system di rete, o NFS, perché la rete viene attivata più avanti;
– configura l’orologio del sistema;
– crea i file ‘/etc/issue’ (vedere ‘agetty’) e ‘/etc/motd’ in modo che rispecchino
la versione in funzione del kernel Linux;
– eventualmente esegue ‘/etc/rc.d/rc.modules’ per l’attivazione di moduli del
kernel;
– eventualmente esegue ‘/etc/rc.d/rc.pcmcia’ per l’attivazione di periferiche
connesse attraverso porte PCMCIA;
4336
4337
– eventualmente esegue ‘/etc/rc.d/rc.serial’ per l’attivazione della porta seriale.
Lo script ‘/etc/rc.d/rc.S’ utilizza a sua volta altri file; quelli elencati di seguito.
– ‘/etc/rc.d/rc.modules’
Script utilizzato da ‘/etc/rc.d/rc.S’ per caricare automaticamente i moduli del
kernel necessari al proprio sistema.
– ‘/etc/rc.d/rc.pcmcia’
Script utilizzato da ‘/etc/rc.d/rc.S’ per l’attivazione delle periferiche connesse
attraverso porte PCMCIA.
– ‘/etc/rc.d/rc.serial’
Script utilizzato da ‘/etc/rc.d/rc.S’ per l’attivazione delle porte seriali, in caso di
utilizzo di terminali connessi con queste.
• ‘/etc/rc.d/rc.0’ --> ‘/etc/rc.d/rc.6’
È lo script che viene eseguito quando si passa a un livello di esecuzione pari a ‘0’ (system
halt) o ‘6’ (reboot). Elimina tutti i processi in esecuzione, esegue lo smontaggio di tutti i
dischi e quindi ferma il sistema o lo riavvia a seconda che si tratti del livello di esecuzione
‘0’ o ‘6’.
• ‘/etc/rc.d/rc.K’
È lo script che viene eseguito quando si passa a un livello di esecuzione pari a ‘1’: singolo
utente, ovvero, livello amministrativo. Elimina tutti i processi dei demoni (la lettera ‘K’ sta
per Kill) e mette il sistema in modalità monoutente. Di conseguenza, non viene eseguito
alcun distacco di dischi.
• ‘/etc/rc.d/rc.M’
È lo script che viene eseguito quando si passa a un livello di esecuzione da ‘2’ a ‘5’: multi utente. Fondamentalmente si occupa di eseguire altri script per il montaggio di dischi
aggiuntivi, per l’attivazione della rete,... In particolare:
– avvia ‘setterm’ in modo da definire l’oscuramento dello schermo dopo alcuni minuti
di inattività;
– esegue ‘/etc/rc.d/rc.cdrom’ per il montaggio del CD-ROM;
– se manca il file ‘/etc/HOSTNAME’, lo crea, inserendovi un nome di dominio
corrispondente a quello predefinito per la distribuzione;
– assegna il nome all’elaboratore in base al contenuto di ‘/etc/HOSTNAME’;
– esegue ‘/etc/rc.d/rc.inet1’ e ‘/etc/rc.d/rc.inet2’ per l’attivazione della
rete;
– avvia ‘/usr/sbin/crond’;
– elimina i file di lock;
– risistema i permessi delle directory più importanti;
– esegue ‘ldconfig’ in modo da aggiornare il file ‘/etc/ld.so.cache’ con i
collegamenti corretti alle librerie installate;
– avvia il servente SMTP per la gestione della posta;
– esegue eventualmente ‘/etc/rc.d/rc.font’ per la gestione dei caratteri del video;
– esegue eventualmente ‘/etc/rc.d/rc.ibcs2’ per l’emulazione iBCS (Intel binary
compatibility Specification);
4338
– esegue ‘/etc/rc.d/rc.keymap’ per cambiare la configurazione della tastiera in
base alla nazionalità;
– esegue eventualmente ‘/etc/rc.d/rc.httpd’ per l’avvio del servente HTTP;
– esegue ‘/etc/rc.d/rc.local’ che è in pratica lo script finale lasciato alla configurazione personale; di solito contiene già l’attivazione del programma ‘gpm’ in
background, per la gestione del mouse.
Lo script ‘/etc/rc.d/rc.M’ utilizza a sua volta altri file, elencati di seguito.
– ‘/etc/rc.d/rc.cdrom’
Script utilizzato da ‘/etc/rc.d/rc.M’ per eseguire automaticamente il montaggio
del CD-ROM. Può creare più problemi che benefici. Al massimo è necessario quando
si utilizza un file system ‘/usr’ da CD-ROM.
– ‘/etc/rc.d/rc.inet1’
Permette di definire le caratteristiche della connessione in rete, oltre ad attivare le
interfacce e definire gli instradamenti. Occorre modificare questo script per cambiare
la configurazione di rete.
– ‘/etc/rc.d/rc.inet2’
Attiva tutti i servizi di rete. Può essere modificato per eliminare o aggiungere servizi.
– ‘/etc/rc.d/rc.local’
È lo script che viene eseguito per ultimo e può essere modificato per qualunque scopo,
legato alla personalizzazione del proprio sistema.
• ‘/etc/rc.d/rc.4’
È lo script che viene eseguito quando si passa a un livello di esecuzione pari a ‘4’: avvia
‘xdm’ in modo da ottenere una procedura di accesso grafica all’interno di X.
• ‘/etc/rc.d/rc.n ’
Volendo definire delle modalità di funzionamento differenti da quelle predefiniti, si può
creare un file ‘rc’ a partire da ‘rc.M’ o ‘rc.4’ e abbinandolo a un livello di esecuzione non
utilizzato (due o cinque) all’interno del file ‘/etc/inittab’.
380.2 Configurazione della rete
La distribuzione Slackware non utilizza file di configurazione per definire l’impostazione della
rete. Questo obbliga praticamente alla modifica diretta degli script che si occupano di definire
gli indirizzi, gli instradamenti e l’attivazione dei servizi. Si tratta di ‘/etc/rc.d/rc.inet1’ e
‘/etc/rc.d/rc.inet2’.
Per la configurazione della rete viene fornito lo script ‘netconfig’ che crea ogni volta un nuovo
file ‘/etc/rc.d/rc.inet1’. Questo però può andare bene solo per le situazioni normali, quando si ha una sola interfaccia di rete e un solo router. Se si decide di modificare direttamente il file
‘/etc/rc.d/rc.inet1’, è meglio fare sparire ‘netconfig’.
Il file ‘/etc/HOSTNAME’ serve a contenere il nome dell’elaboratore (nome di dominio completo)
in modo da poter definire questo nome per mezzo di ‘hostname’ durante la fase di inizializzazione del sistema. Naturalmente, un elaboratore può avere più nomi, tanti quante sono le interfacce
di rete: se ne deve scegliere uno solo.
4339
380.3 Configurazione di shell
Questa distribuzione fornisce solo i file di configurazione principali per le shell che permette di
installare; non sono previste impostazioni predefinite per gli utenti.
Per quanto riguarda la shell Bourne e quelle derivate, è disponibile il file ‘/etc/profile’ un
po’ complicato a causa della necessità, in certi casi, di determinare il tipo di shell utilizzato
effettivamente per stabilire l’azione corretta.
380.4 Utenti
Utenti e gruppi vengono gestiti nel modo tradizionale, per cui la maschera dei permessi utilizzata
normalmente è 0228.
Per quanto riguarda l’utente e il gruppo ‘nobody’, è il caso di osservare che 65534 e -2 sono la
stessa cosa.
Lo script ‘adduser’ inserisce gli utenti a partire dal numero 500 in poi.
380.4.1 /etc/passwd
halt:x:7:0:halt:/sbin:/sbin/halt
operator:x:11:0:operator:/root:/bin/bash
root:x:0:0::/root:/bin/bash
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
sync:x:5:0:sync:/sbin:/bin/sync
bin:x:1:1:bin:/bin:
ftp:x:404:1::/home/ftp:/bin/bash
daemon:x:2:2:daemon:/sbin:
adm:x:3:4:adm:/var/adm:
lp:x:4:7:lp:/var/spool/lpd:
mail:x:8:12:mail:/var/mail:
postmaster:x:14:12:postmaster:/var/mail:/bin/bash
news:x:9:13:news:/usr/lib/news:
uucp:x:10:14:uucp:/var/spool/uucppublic:
man:x:13:15:man:/usr/man:
games:x:12:100:games:/usr/games:
guest:x:405:100:guest:/dev/null:/dev/null
nobody:x:65534:100:nobody:/dev/null:
380.4.2 /etc/group
root::0:root
bin::1:root,bin,daemon
daemon::2:root,bin,daemon
sys::3:root,bin,adm
adm::4:root,adm,daemon
tty::5:
disk::6:root,adm
lp::7:lp
mem::8:
kmem::9:
wheel::10:root
floppy::11:root
mail::12:mail
news::13:news
uucp::14:uucp
man::15:man
users::100:games
nogroup::-2:
4340
Capitolo
381
Script per la gestione dei pacchetti software
381.1 Un sistema per gestire le installazioni tradizionali nella
distribuzione Slackware
Quando si installa un programma distribuito in forma originale, quando cioè lo si deve prima
compilare e poi installare nel modo previsto dall’autore, di solito non si ha la possibilità di
disinstallarlo in un secondo momento.
Gli strumenti forniti dalle distribuzioni Slackware permettono di installare e disinstallare in modo
spartano i programmi, purché siano rispettate certe condizioni. Quando si installa un programma
che prima deve essere compilato e poi installato attraverso uno script o un file-make fatti dall’autore, non è possibile fare in modo che il meccanismo dell’installazione Slackware ne diventi
consapevole.
Perché il programma installato possa essere disinstallabile attraverso gli strumenti Slackware,
occorre creare per lui un file all’interno di ‘/var/log/packages/’ contenente l’elenco dei file
che lo compongono.
In questa sezione viene mostrato uno script da utilizzare per avviare le operazioni di installazione
di un programma distribuito in forma normale, ovvero non nel modo previsto dalla distribuzione Slackware. Quando lo script viene avviato, memorizza la situazione del file system globale,
quindi permette all’utente di svolgere le operazioni necessarie a compiere l’installazione e al termine confronta la nuova situazione del file system con quella precedente per determinare quali
file siano stati aggiunti. In questo modo, viene poi aggiunta la descrizione di un nuovo pacchetto
all’interno di ‘/var/log/packages/’. Lo script può essere utilizzato solo dall’utente ‘root’
ed è opportuno che durante il suo funzionamento non siano in corso altre attività, soprattutto,
nessun’altra applicazione deve creare dei file.
#!/bin/bash
#======================================================================
# SlackwareTrace
#======================================================================
#======================================================================
# Variabili.
#======================================================================
#-----------------------------------------------------------------# Nome per un file temporaneo utilizzato per ricevere le risposte
# all’esecuzione del comando «dialog --inputbox».
#-----------------------------------------------------------------RISPOSTA="/tmp/risposta"
#-----------------------------------------------------------------# Nome per un file temporaneo contenente l’elenco dei file presenti
# nel file system PRIMA.
#-----------------------------------------------------------------ELENCO_FILE_PRIMA="/tmp/elenco_PRIMA"
# nel file system DOPO.
#-----------------------------------------------------------------ELENCO_FILE_DOPO="/tmp/elenco_DOPO"
#-----------------------------------------------------------------# Nome per un file temporaneo contenente l’elenco dei file aggiunti
# nel file system dopo le operazioni di installazione.
#-----------------------------------------------------------------ELENCO_FILE_AGGIUNTI="/tmp/elenco_AGGIUNTI"
4341
4342
#-----------------------------------------------------------------# Variabile utilizzata per ricevere i comandi.
#-----------------------------------------------------------------COMANDO=""
#-----------------------------------------------------------------# Variabile utilizzata per ricevere il nome del pacchetto.
#-----------------------------------------------------------------PACCHETTO=""
#-----------------------------------------------------------------# Variabile utilizzata per ricevere la descrizione del pacchetto.
#-----------------------------------------------------------------DESCRIZIONE=""
#-----------------------------------------------------------------# Variabile utilizzata per salvare il prompt.
#-----------------------------------------------------------------SALVA_PROMPT=$PS1
#======================================================================
# Inizio.
#======================================================================
#-----------------------------------------------------------------# Verifica la quantità di argomenti.
#-----------------------------------------------------------------if [ $# != 0 ]
then
echo "Questo script è completamente interattivo e quindi non \
utilizza alcun argomento."
exit 1
fi
#-----------------------------------------------------------------# Verifica che l’utente sia ’root’.
#-----------------------------------------------------------------if [ $UID != 0 ]
then
echo "Questo script può essere utilizzato solo dall’utente \
’root’."
exit 1
fi
#-----------------------------------------------------------------# Salva la situazione del file system PRIMA.
# Sono esclusi i percorsi «/tmp», «/proc» e «/mnt».
#-----------------------------------------------------------------reset
echo "---------------------------------------------------"
echo "È in corso la scansione del file system per "
echo "determinare la situazione iniziale dei file esistenti."
echo ""
echo "Attendere prego..."
echo "---------------------------------------------------"
find \
/ -path "/proc" -prune -o -path "/tmp" -prune -o -path "/mnt" -prune \
-o -print | sort > $ELENCO_FILE_PRIMA
#-----------------------------------------------------------------# Avvia una subshell per l’esecuzione dei comandi necessari
# all’installazione. Si comincia dall’avvisare l’utente.
#-----------------------------------------------------------------reset
dialog --msgbox \
"Attenzione! Sta per essere avviata una subshell per\
\n\
l’esecuzione dei comandi necessari all’installazione\
\n\
del software.\
\n\
Di solito si tratta di eseguire qualcosa di molto simile\
\n\
a ’make install’.\
\n\
\n\
Al termine si dovrà tornare allo script utilizzando\
\n\
il comando exit." \
18 70
#-----------------------------------------------------------------# Modifica il prompt.
#-----------------------------------------------------------------PS1=\
"Eseguire i comandi necessari a compiere l’installazione \
quindi utilizzare il comando exit per tornare allo script.\
\n\
$0>"
export PS1
#-----------------------------------------------------------------# Avvia la subshell.
#-----------------------------------------------------------------/bin/sh
#-----------------------------------------------------------------# Ripristina il prompt.
#-----------------------------------------------------------------PS1=$SALVA_PROMPT
export PS1
#-----------------------------------------------------------------# Salva la situazione del file system DOPO.
#-----------------------------------------------------------------reset
echo "---------------------------------------------------"
echo "È in corso la scansione del file system per "
echo "determinare la nuova situazione dei file esistenti."
echo ""
echo "Attendere prego..."
echo "---------------------------------------------------"
find \
-print | sort > $ELENCO_FILE_DOPO
#-----------------------------------------------------------------# Confronta i due file ed emette solo le righe del secondo elenco
# che non appaiono nel primo.
# Salva il risultato in un altro file temporaneo.
#-----------------------------------------------------------------comm -13 \
$ELENCO_FILE_PRIMA $ELENCO_FILE_DOPO > $ELENCO_FILE_AGGIUNTI
#-----------------------------------------------------------------# Verifica che il file generato non sia vuoto.
#-----------------------------------------------------------------if [ -z "‘cat $ELENCO_FILE_AGGIUNTI‘" ]
then
#-------------------------------------------------------------# Non ha trovato alcun file in più rispetto alla
# situazione precedente. Lo script avvisa e termina.
#-------------------------------------------------------------reset
dialog --msgbox \
"Non è stato aggiunto alcun file.\
\n\
Non verrà fatta alcuna registrazione di questa installazione." \
7 70
exit 2
fi
#-----------------------------------------------------------------# Richiede il nome del pacchetto.
4343
4344
#-----------------------------------------------------------------while [ 0 ]
# FOREVER
do
reset
dialog --inputbox \
"Inserisci il nome da usare per identificare questo pacchetto.\
\n\
Per seguire la convenzione usata dalla procedura di installazione\
\n\
Slackware, si possono usare solo otto caratteri.\
\n\
Il nome del pacchetto servirà per creare un file contenere le\
\n\
informazioni sul pacchetto, di conseguenza, occorre rispettare le\
\n\
regole per i nomi dei file.\
\n\
\n\
\n\
<Ok> prosegue,\
\n\
<Cancel> ripete la richiesta." \
17 70 2> $RISPOSTA
#-------------------------------------------------------------# Controlla la risposta data dall’utente.
#-------------------------------------------------------------if [ $? = 0 ]
then
#---------------------------------------------------------# La risposta è stata un OK e quindi prosegue.
#---------------------------------------------------------PACCHETTO=‘cat $RISPOSTA‘
else
#---------------------------------------------------------# La risposta è stata un CANCEL e quindi ripete il loop.
#---------------------------------------------------------continue
fi
#-------------------------------------------------------------# Controlla che il nome non sia già utilizzato.
#-------------------------------------------------------------if [ -e "/var/log/packages/$PACCHETTO" ]
then
#---------------------------------------------------------# Il nome esiste già. Ripete il loop.
#---------------------------------------------------------reset
dialog --msgbox \
"Attenzione! il nome $PACCHETTO è già stato usato.\
\n\
Se ne deve inserire un altro."\
6 70
continue
fi
#-------------------------------------------------------------# Controlla che il nome sia accettabile tentando di creare
# un file con quello.
#-------------------------------------------------------------rm "/tmp/$PACCHETTO"
echo "prova" > "/tmp/$PACCHETTO"
#-------------------------------------------------------------# Se è riuscito a creare il file, tutto dovrebbe
# essere in ordine.
#-------------------------------------------------------------if [ -e "/tmp/$PACCHETTO" ]
then
#---------------------------------------------------------# Il nome è valido.
#---------------------------------------------------------echo "ok" > /dev/null
else
#---------------------------------------------------------# Il nome non è valido. Ripete il loop.
#---------------------------------------------------------reset
dialog --msgbox \
"Attenzione! il nome $PACCHETTO non è valido.\
\n\
Se ne deve inserire un altro." \
7 70
continue
fi
#-------------------------------------------------------------# Se sono stati superati tutti gli ostacoli, il loop viene
# interrotto.
#-------------------------------------------------------------break
done
#-----------------------------------------------------------------# Finalmente è stato inserito il nome del pacchetto.
# Si passa ora alla sua descrizione.
#-----------------------------------------------------------------while [ 0 ]
# FOREVER
do
reset
dialog --inputbox \
"Inserisci una breve descrizione del pacchetto.\
\n\
\n\
\n\
<Ok> prosegue,\
\n\
12 70 2> $RISPOSTA
#-------------------------------------------------------------if [ $? = 0 ]
then
#---------------------------------------------------------DESCRIZIONE=‘cat $RISPOSTA‘
else
#---------------------------------------------------------continue
fi
# interrotto.
#-------------------------------------------------------------break
done
#-----------------------------------------------------------------# Scrive il file del pacchetto.
#-----------------------------------------------------------------echo "PACKAGE NAME:
$PACCHETTO" > /var/log/packages/$PACCHETTO
echo "COMPRESSED PACKAGE SIZE:" >> /var/log/packages/$PACCHETTO
echo "UNCOMPRESSED PACKAGE SIZE:" >> /var/log/packages/$PACCHETTO
echo "PACKAGE LOCATION:" >> /var/log/packages/$PACCHETTO
4345
4346
echo "PACKAGE DESCRIPTION:" >> /var/log/packages/$PACCHETTO
echo "$PACCHETTO: $DESCRIZIONE" >> /var/log/packages/$PACCHETTO
echo "$PACCHETTO:" >> /var/log/packages/$PACCHETTO
echo "FILE LIST:" >> /var/log/packages/$PACCHETTO
cat $ELENCO_FILE_AGGIUNTI >> /var/log/packages/$PACCHETTO
#-----------------------------------------------------------------# Avvisa l’utente della conclusione dell’operazione.
#-----------------------------------------------------------------reset
dialog --msgbox \
"La registrazione del pacchetto $PACCHETTO è terminata." \
5 70
#======================================================================
# Fine.
#======================================================================
Prima di poter eseguire uno script è importante attribuirgli i permessi di esecuzione necessari.
chmod +x nome_del_file
381.2 Fare da sé
Quando si utilizza una distribuzione GNU/Linux ben organizzata è un peccato pasticciarla con
programmi o altri file installati nel modo tradizionale (‘make install’). In questa sezione si
propone un semplice script fatto per tenere traccia di queste installazioni.
Quando lo script viene avviato, memorizza la situazione del file system, quindi permette all’utente di svolgere le operazioni necessarie a compiere l’installazione e al termine confronta la nuova
situazione del file system con quella precedente per determinare quali file siano stati aggiunti.
In questo modo, viene poi aggiunta la descrizione di un nuovo pacchetto all’interno di ‘/var/
state/mypackages/’. Lo script può essere utilizzato solo dall’utente ‘root’ ed è opportuno
che durante il suo utilizzo non siano in corso altre attività, soprattutto, nessun’altra applicazione
deve creare dei file.
#!/bin/bash
#======================================================================
# traccia
#======================================================================
#======================================================================
# Variabili.
#======================================================================
#-----------------------------------------------------------------# Nome per un file temporaneo utilizzato per ricevere le risposte
# all’esecuzione del comando «dialog --inputbox».
#-----------------------------------------------------------------RISPOSTA="/tmp/risposta"
# nel file system PRIMA.
#-----------------------------------------------------------------ELENCO_FILE_PRIMA="/tmp/elenco_PRIMA"
# nel file system DOPO.
#------------------------------------------------------------------
ELENCO_FILE_DOPO="/tmp/elenco_DOPO"
#-----------------------------------------------------------------# Nome per un file temporaneo contenente l’elenco dei file aggiunti
# nel file system dopo le operazioni di installazione.
#-----------------------------------------------------------------ELENCO_FILE_AGGIUNTI="/tmp/elenco_AGGIUNTI"
#-----------------------------------------------------------------# Variabile utilizzata per ricevere i comandi.
#-----------------------------------------------------------------COMANDO=""
#-----------------------------------------------------------------# Variabile utilizzata per ricevere il nome del pacchetto.
#-----------------------------------------------------------------PACCHETTO=""
#-----------------------------------------------------------------# Variabile utilizzata per ricevere la descrizione del pacchetto.
#-----------------------------------------------------------------DESCRIZIONE=""
#-----------------------------------------------------------------# Variabile utilizzata per salvare il prompt.
#-----------------------------------------------------------------SALVA_PROMPT=$PS1
#======================================================================
# Inizio.
#======================================================================
#-----------------------------------------------------------------# Verifica la quantità di argomenti.
#-----------------------------------------------------------------if [ $# != 0 ]
then
dialog --msgbox \
"Questo script è completamente interattivo e quindi non \
\n\
utilizza alcun argomento." \
6 70
exit 1
fi
#-----------------------------------------------------------------# Verifica che l’utente sia ’root’.
#-----------------------------------------------------------------if [ $UID != 0 ]
then
dialog --msgbox \
"Questo script può essere utilizzato solo dall’utente \
\n\
’root’." \
6 70
exit 1
fi
#-----------------------------------------------------------------# Salva la situazione del file system PRIMA.
#-----------------------------------------------------------------reset
dialog --infobox \
"È in corso la scansione del file system per \
\n\
determinare la situazione iniziale dei file esistenti. \
\n\
\n\
Attendere prego... \
" \
6 70
find \
4347
4348
-o -print | sort > $ELENCO_FILE_PRIMA
#-----------------------------------------------------------------# Avvia una subshell per l’esecuzione dei comandi necessari
# all’installazione. Si comincia dall’avvisare l’utente.
#-----------------------------------------------------------------reset
dialog --msgbox \
"Attenzione! Sta per essere avviata una subshell per\
\n\
l’esecuzione dei comandi necessari all’installazione\
\n\
del software.\
\n\
Di solito si tratta di eseguire qualcosa di molto simile\
\n\
a ’make install’.\
\n\
\n\
Al termine si dovrà tornare allo script utilizzando\
\n\
il comando exit." \
12 70
#-----------------------------------------------------------------# Modifica il prompt.
#-----------------------------------------------------------------PS1=\
"Eseguire i comandi necessari a compiere l’installazione \
quindi utilizzare il comando exit per tornare allo script.\
\n\
\w>"
export PS1
#-----------------------------------------------------------------# Avvia la subshell.
#-----------------------------------------------------------------/bin/sh
#-----------------------------------------------------------------# Ripristina il prompt.
#-----------------------------------------------------------------PS1=$SALVA_PROMPT
export PS1
#-----------------------------------------------------------------# Salva la situazione del file system DOPO.
#-----------------------------------------------------------------reset
dialog --infobox \
"È in corso la scansione del file system per \
\n\
determinare la nuova situazione dei file esistenti. \
\n\
\n\
Attendere prego... \
" \
6 70
find \
-o -print | sort > $ELENCO_FILE_DOPO
#-----------------------------------------------------------------# Confronta i due file ed emette solo le righe del secondo elenco
# che non appaiono nel primo.
# Salva il risultato in un altro file temporaneo.
#-----------------------------------------------------------------comm -13 \
$ELENCO_FILE_PRIMA $ELENCO_FILE_DOPO > $ELENCO_FILE_AGGIUNTI
#------------------------------------------------------------------
# Verifica che il file generato non sia vuoto.
#-----------------------------------------------------------------if [ -z "‘cat $ELENCO_FILE_AGGIUNTI‘" ]
then
#-------------------------------------------------------------# Non ha trovato alcun file in più rispetto alla
# situazione precedente. Lo script avvisa e termina.
#-------------------------------------------------------------reset
dialog --msgbox \
"Non è stato aggiunto alcun file.\
\n\
Non verrà fatta alcuna registrazione di questa installazione." \
6 70
exit 2
fi
#-----------------------------------------------------------------# Richiede il nome del pacchetto.
#-----------------------------------------------------------------while [ 0 ]
# FOREVER
do
reset
dialog --inputbox \
"Inserisci il nome da usare per identificare questo pacchetto.\
\n\
\n\
Il nome del pacchetto servirà per creare un file contenere le\
\n\
informazioni sul pacchetto, di conseguenza, occorre rispettare le\
\n\
regole per i nomi dei file.\
\n\
\n\
\n\
<Ok> prosegue,\
\n\
16 70 2> $RISPOSTA
#-------------------------------------------------------------if [ $? = 0 ]
then
#---------------------------------------------------------PACCHETTO=‘cat $RISPOSTA‘
else
#---------------------------------------------------------continue
fi
#-------------------------------------------------------------# Controlla che il nome non sia già utilizzato.
#-------------------------------------------------------------if [ -e "/var/state/mypackages/$PACCHETTO" ]
then
#---------------------------------------------------------# Il nome esiste già. Ripete il loop.
#---------------------------------------------------------reset
dialog --msgbox \
"Attenzione! il nome $PACCHETTO è già stato usato.\
\n\
4349
4350
6 70
continue
fi
#-------------------------------------------------------------# Controlla che il nome sia accettabile tentando di creare
# un file con quello.
#-------------------------------------------------------------rm "/tmp/$PACCHETTO"
touch "/tmp/$PACCHETTO"
#-------------------------------------------------------------# Se è riuscito a creare il file, tutto dovrebbe
# essere in ordine.
#-------------------------------------------------------------if [ -e "/tmp/$PACCHETTO" ]
then
#---------------------------------------------------------# Il nome è valido.
#---------------------------------------------------------echo "ok" > /dev/null
else
#---------------------------------------------------------# Il nome non è valido. Ripete il loop.
#---------------------------------------------------------reset
dialog --msgbox \
"Attenzione! il nome $PACCHETTO non è valido.\
\n\
6 70
continue
fi
# interrotto.
#-------------------------------------------------------------break
done
#-----------------------------------------------------------------# Finalmente è stato inserito il nome del pacchetto.
# Si passa ora alla sua descrizione.
#-----------------------------------------------------------------while [ 0 ]
# FOREVER
do
reset
dialog --inputbox \
"Inserisci una breve descrizione del pacchetto.\
\n\
\n\
\n\
<Ok> prosegue,\
\n\
12 70 2> $RISPOSTA
#-------------------------------------------------------------if [ $? = 0 ]
then
#---------------------------------------------------------DESCRIZIONE=‘cat $RISPOSTA‘
else
#----------------------------------------------------------
4351
continue
fi
# interrotto.
#-------------------------------------------------------------break
done
#-----------------------------------------------------------------# Scrive i file del pacchetto.
#-----------------------------------------------------------------echo "$DESCRIZIONE" > /var/state/mypackages/$PACCHETTO.descr
cat $ELENCO_FILE_AGGIUNTI > /var/state/mypackages/$PACCHETTO
#-----------------------------------------------------------------# Avvisa l’utente della conclusione dell’operazione.
#-----------------------------------------------------------------reset
dialog --msgbox \
"La registrazione del pacchetto \
\n\
$PACCHETTO \
\n\
è terminata." \
7 70
#======================================================================
# Fine.
#======================================================================
Prima di poter eseguire uno script è importante ricordare di attribuirgli i permessi di esecuzione
necessari.
chmod +x nome_del_file
4352
Parte lxxxii
Informazioni varie
382 Emulatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4354
382.1 WINE: l’emulatore MS-Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4354
382.2 Twin: un altro emulatore MS-Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4356
383 nanoRouter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4358
383.1 Kernel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4358
383.2 Lo stretto indispensabile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4358
383.3 Dimensioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4361
383.4 File system in sola lettura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4361
384 X-ISP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4362
385 Introduzione a SMB con GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4366
385.1 Nomi NetBIOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4366
385.2 Trasporto TCP/IP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4367
385.3 Servente SMB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4367
385.4 Cliente SMB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4372
385.5 Connessione con una rete NetBIOS-TCP/IP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4374
385.6 Stampa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4377
385.7 Montare una risorsa di condivisione dei file nel file system GNU/Linux . . . . 4378
385.8 Riferimenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4380
386 Applicazioni multimediali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4381
386.1 Wavplay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4381
386.2 Mpg123 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4383
386.3 8Hz-mp3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4383
386.4 Xanim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4384
387 Acua . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4386
387.1 Organizzazione generale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4386
387.2 Preparazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4389
387.3 Gestione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4395
387.4 Funzionamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4403
387.5 Altra configurazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4406
4353
Capitolo
382
Emulatori
Su una piattaforma GNU/Linux è possibile utilizzare programmi realizzati per altri sistemi operativi, attraverso vari tipi di emulatori. In generale, questa emulazione può avvenire in due modi
fondamentali: riproducendo il funzionamento dell’hardware di un tipo di elaboratore, oppure riproducendo interamente il funzionamento di un altro sistema operativo. La prima delle due scelte implica l’utilizzo successivo di un sistema operativo in grado di utilizzare l’emulatore hardware e con il quale si possono poi utilizzare altri programmi. La seconda, permette di utilizzare
direttamente i programmi adatti al tipo di sistema operativo che viene emulato.
Le implicazioni sulla differenza tra l’emulazione dell’hardware e quella di un sistema operativo
sono sia tecniche che giuridiche. Se si emula l’hardware occorre poi procurarsi il sistema operativo e soprattutto la licenza di questo. Se si emula l’hardware spesso è necessario copiare da
qualche parte il contenuto del firmware (programma su ROM) utilizzato nell’elaboratore da emulare. Ma questo, nella maggior parte dei casi, è un’azione illegale (anche se non si sente parlare
di cause contro azioni di questo genere).
382.1 WINE: l’emulatore MS-Windows
WINE è un programma che permette di eseguire programmi realizzati per MS-Windows
all’interno dell’ambiente grafico X. WINE è quindi un emulatore di MS-Windows.
Nel momento in cui si scriveva questo capitolo, WINE era in grado di fare funzionare (senza però
alcuna sicurezza) solo alcuni programmi realizzati per MS-Windows 3.1.
Per poter utilizzare WINE potrebbero essere necessari alcuni componenti di MS-Windows
3.1 (delle librerie). In tal caso, oltre che esserci bisogno di una copia di MS-Windows 3.1 è
necessaria anche una licenza d’uso.
Lo sviluppo di WINE può essere seguito presso l’URI <http://www.linpro.no/wine/>.
382.1.1 Predisporre un ambiente adatto ai programmi per WINE
Dal momento che i programmi realizzati per MS-Windows sono stati pensati per lo più per funzionare su un file system di tipo FAT, sarebbe consigliabile di riservare loro una partizione di
questo tipo. Tuttavia, potrebbe essere molto più affascinante l’idea di incorporare tutto all’interno
del file system di GNU/Linux e in questo senso sono realizzati gli esempi seguenti.
382.1.2 Un disco C: virtuale
In questa fase conviene preparare una directory che servirà per definire l’inizio (la radice) del
disco ‘C:’ virtuale utilizzato dai programmi per MS-Windows. Stabiliamo che questo sia ‘/var/
emul/windows/’. Da questo punto in poi, ‘C:\’ è equivalente a ‘/var/emul/windows/’.
4354
Emulatori
4355
382.1.3 La struttura essenziale del disco C: virtuale
Il disco ‘C:’ virtuale dovrebbe contenere alcune directory che riproducono in pratica il classico
ambiente DOS-Windows:
• ‘C:\TEMP\’
equivalente a ‘/var/emul/windows/temp/’;
• ‘C:\WINDOWS\’
equivalente a ‘/var/emul/windows/windows/’;
• ‘C:\WINDOWS\SYSTEM\’
equivalente a ‘/var/emul/windows/windows/system/’.
Per evitare la proliferazione di directory temporanee, è possibile utilizzare al posto di ‘/var/
emul/windows/temp/’ un collegamento simbolico che punti a ‘/tmp/’.
# ln -s /tmp /var/emul/windows/temp
Una volta preparata la struttura essenziale occorre inserire alcuni file.
All’interno di ‘/var/emul/windows/windows/’ (‘C:\WINDOWS\’) si devono preparare alcuni
file ‘.INI’ vuoti. Si tratta di ‘WIN.INI’ e di ‘SYSTEM.INI’.
# touch /var/emul/windows/windows/win.ini
# touch /var/emul/windows/windows/system.ini
All’interno di ‘/var/emul/windows/windows/system/’ (‘C:\WINDOWS\SYSTEM\’) potrebbe essere necessario collocare alcuni file di libreria provenienti da una versione originale di MSWindows 3.1 (come già spiegato, questo implica la necessità di avere una licenza d’uso per
MS-Windows 3.1). Probabilmente, i file seguenti sono indispensabili.
• ‘COMMDLG.DLL’
• ‘CTL3DV2.DLL’
• ‘DDEML.DLL’
• ‘LZEXPAND.DLL’
• ‘OLECLI.DLL’
• ‘VBRUN300.DLL’
382.1.4 La configurazione di WINE
Il file ‘/etc/wine.conf’ deve essere predisposto prima di poter eseguire alcuna emulazione.
L’esempio seguente fa riferimento alla struttura di directory vista in precedenza. In particolare,
all’interno di GNU/Linux, il dischetto viene montato nella directory ‘/mnt/a/’.
[Drive A]
Path=/mnt/a
Type=floppy
[Drive C]
Emulatori
4356
Path=/var/emul/windows
Label=ext2fs
[Drive D]
Path=${HOME}
[wine]
windows=c:\windows
system=c:\windows\system
temp=c:\temp
path=c:\windows;c:\windows\system
symboltablefile=./wine.sym
[serialports]
com1=/dev/cua1
com2=/dev/cua2
[parallelports]
lpt1=/dev/lp1
[spy]
;File=CON
;File=spy.log
Exclude=WM_TIMER;WM_SETCURSOR;WM_MOUSEMOVE;WM_NCHITTEST;
Include=WM_COMMAND;
382.1.5 L’esecuzione di un programma
Per mettere in esecuzione un programma attraverso WINE è necessario avviare prima l’ambiente
grafico (di solito attraverso ‘startx’), quindi aprire una finestra di terminale e da lì eseguire il
comando seguente:
wine
[opzioni]
programma_completo_di_percorso
Per esempio, per avviare il file ‘PFE.EXE’ che si trova all’interno di ‘C:\PFE\’ si eseguirà:
$ wine "c:\pfe\pfe"
oppure la riga seguente:
$ wine /var/emul/windows/pfe/pfe.exe
382.1.6 Implicazioni sulla gestione dei permessi
WINE si comporta in maniera analoga a DOSEMU per quanto riguarda il problema della gestione
dei permessi dei file e delle directory. Valgono quindi le stesse considerazioni fatte a questo
proposito nella sezione 343.3.7.
382.2 Twin: un altro emulatore MS-Windows
Twin, ovvero Willows Twin Libraries, è un sistema di emulazione che permette di eseguire
programmi realizzati per MS-Windows all’interno dell’ambiente grafico X.
Si tratta di un progetto parallelo a WINE; Twin, in particolare, ha il vantaggio di fornire al
programma utilizzato un livello di astrazione superiore rispetto a quanto fatto da WINE, per
cui i programmi funzionano in finestre normali di X. La cosa più importante è che non serve
alcun componente originale di MS-Windows: tutte le librerie principali sono emulate.
Emulatori
<http://www.willows.com>
4357
Capitolo
383
nanoRouter
nanoRouter è un lavoro che riguarda la prima edizione di nanoLinux e non è più curato. Questo
capitolo è obsoleto e viene lasciato per documentare il funzionamento di questo dischetto che
viene ancora distribuito con Appunti di informatica libera.
L’inoltro dei pacchetti da un’interfaccia di rete a un’altra, in un router, è compito del kernel: è
sufficiente che gli venga fornita la configurazione delle interfacce e la tabella di instradamento.
Teoricamente dovrebbe essere possibile compilare un kernel con questi valori già registrati al
suo interno, in pratica conviene utilizzare il modo tradizionale di configurazione attraverso i
programmi ‘ifconfig’ e ‘route’.
Un dischetto di emergenza, in grado di accedere alle interfacce di rete, con un kernel adatto e con
questi due programmi, è in grado di funzionare come router. Ciò vale quindi sia per nanoLinux
che per i dischetti di emergenza della distribuzione Slackware.
In questo capitolo si descrive in che modo ottenere un sistema estremamente ridotto in grado di
eseguire l’inoltro di pacchetti da un’interfaccia di rete a un’altra.
383.1 Kernel
Come già accennato, il kernel deve consentire l’inoltro dei pacchetti. Per le altre caratteristiche
valgono tutte le considerazioni già fatte al riguardo dei dischetti di emergenza.
383.2 Lo stretto indispensabile
La funzione di inoltro è svolta dal kernel e, a meno di essere abili programmatori, è necessario
utilizzare ‘ifconfig’ e ‘route’ per configurare le interfacce e definire gli instradamenti. Questi
programmi, a loro volta, hanno bisogno di librerie. I programmi, per essere avviati hanno bisogno
dell’eseguibile ‘init’, oppure, in alternativa, di una shell che possa eseguire uno script.
Nell’esempio proposto non si fa uso di ‘init’: con un piccolo trucco si avvia direttamente la
shell ‘ash’ in modo interattivo, così da leggere ed eseguire il file ‘/etc/profile’ contenente le
istruzioni per la configurazione delle interfacce e la definizione degli instradamenti.
Rispetto ai dischetti di emergenza normali si pone un nuovo problema: l’identificazione delle
interfacce di rete quando queste sono più di una. Infatti, il kernel smette di cercare altre interfacce
dopo che ne ha trovata una. Ciò costringe in pratica a utilizzare LILO, attraverso il quale si
possono definire le istruzioni che il kernel deve ricevere all’avvio (attraverso queste istruzioni
può essere informato della presenza di altre schede di rete).
L’esempio mostrato è stato realizzato con file binari e librerie di una vecchia distribuzione
Slackware 3.1. Le restrizioni che si impongono allo scopo di realizzare un dischetto unico,
non compresso, in sola lettura, rendono praticamente impossibile l’utilizzo di programmi e
librerie più recenti.
4358
nanoRouter
4359
383.2.1 Struttura di nanoRouter
Il dischetto nanoRouter si ottiene partendo da nanoLinux I eliminando molte cose e aggiungendone poche altre. In particolare, si nota subito l’utilizzo di ‘ash’ al posto di ‘bash’ e la totale
assenza della procedura di inizializzazione del sistema.
Il programma ‘/sbin/init’ è scomparso, al suo posto c’è un collegamento simbolico speciale
che avvia ‘ash’ con l’opzione ‘-i’: in questo modo, quando il kernel tenta di avviare ‘init’,
avvia invece una shell interattiva che, come tale, esegue il contenuto di ‘/etc/profile’.
Anche ‘/sbin/ldconfig’ è un collegamento simbolico: avvia uno script che restituisce semplicemente il valore Vero. Questo programma viene avviato automaticamente e non può mancare
(anche se di fatto non serve).
I file di dispositivo contenuti all’interno di ‘/dev/’ sono ridotti al minimo, in pratica ci sono i
dispositivi di gestione della console e poco altro.
L’ultima cosa da notare è la presenza della directory ‘/boot/’ contenente il kernel e i file di
avvio di LILO.
/
|-|
|
|
|
|-|
|
|
|
|
|-|
|
|
|
|
|
|
|
|
|
|-|
|
|
|
|-|
|
|
|
|
|
|
|
|
|-|-|-|
|
|
bin
|-- ash
|-- ping
|-- sh -> ash
‘-- sync
boot
|-- .config
|-- boot.0200
|-- boot.b
|-- map
‘-- vmlinuz
dev
|-- log
|-- null
|-- systty
|-- tty
|-- tty0
|-- tty1
|-- tty2
|-- tty3
|-- tty4
‘-- zero
etc
|-- ld.so.cache
|-- lilo.conf
|-- profile
‘-- protocols
lib
|-- ld-linux.so -> ld-linux.so.1
|-- ld-linux.so.1 -> ld-linux.so.1.8.2
|-- ld-linux.so.1.8.2
|-- libc.so.5 -> libc.so.5.3.12
|-- libc.so.5.3.12
|-- libcom_err.so.2 -> libcom_err.so.2.0
|-- libcom_err.so.2.0
|-- libtermcap.so.2 -> libtermcap.so.2.0.8
‘-- libtermcap.so.2.0.8
mnt
proc
sbin
|-- ifconfig
|-- init -> ../bin/ash -i
|-- ldconfig -> true
4360
|
|
|
|-|-‘--
nanoRouter
|-- route
|-- true
‘-- update
tmp
usr
var
383.2.2 Collegamento con argomento
Creare un collegamento simbolico con un argomento non è possibile attraverso il solito programma ‘ln’. Se non si riesce, si può creare un collegamento simbolico normale, ma poi, occorre
avviare manualmente l’esecuzione del file ‘profile’.
Attraverso ‘mc’ (Midnight Commander) è possibile modificare un collegamento simbolico scrivendoci quello che si vuole. Basta richiamare la voce edit sYmlink dal menù File, oppure
utilizzare la sequenza [ Ctrl+x ][ Ctrl+s ].
383.2.3 /etc/profile
Il file ‘/etc/profile’, in questo tipo di impostazione, è l’unico mezzo di configurazione. La
configurazione delle interfacce di rete e la definizione degli instradamenti avvengono all’interno
di questo file.
PATH="/sbin:/bin:."
TERM=linux
PS1=’# ’
PS2=’> ’
ignoreeof=10
export PATH TERM PS1 PS2 ignoreeof
umask 022
/sbin/ifconfig eth0 192.168.1.254 netmask 255.255.255.0
/sbin/ifconfig plip1 192.168.2.254 pointopoint 192.168.2.1
/sbin/route add -net 192.168.1.0 netmask 255.255.255.0 dev eth0
/sbin/route add -host 192.168.2.1 dev plip1
ifconfig
383.2.4 /boot/
Come già accennato, esiste l’esigenza di comunicare al kernel l’esistenza di diverse schede di
rete (altrimenti si può forse usare solo la porta parallela come seconda interfaccia di rete). Serve
quindi il sistema di avvio LILO. Il modo con cui è possibile ottenere un dischetto contenente
LILO è descritto nella sezione 18.4.
Il contenuto del file di esempio si riferisce in particolare ai parametri delle schede NE2000.
# /etc/lilo.conf
boot=/dev/fd0
map=/boot/map
install=/boot/boot.b
image=/boot/vmlinuz
label=router
root=/dev/fd0
read-only
append="ether=0,0x300,eth0 ether=0,0x320,eth1 ether=0,0x340,eth2"
Vale la pena di notare che il file system principale viene attivato in sola lettura e non viene mai
riportato in lettura-scrittura.
nanoRouter
4361
383.3 Dimensioni
Tutto quanto, compreso il kernel, dovrebbe essere contenibile all’interno di un dischetto da
1440 Kibyte, senza alcuna compressione. In questo modo non c’è la necessità di utilizzare un
disco RAM e anche un elaboratore con poca memoria potrebbe svolgere degnamente questo
compito (senza bisogno di una laboriosa configurazione).
383.4 File system in sola lettura
Il fatto che si riesca a operare senza eseguire scritture sul disco, pur non utilizzando un disco RAM, permette di non dover temere cadute di tensione o errori umani: Quando non serve
più, basta spegnere.
Resta un problema dovuto al fatto che il kernel, una volta caricato in memoria, richiede la pressione del tasto [ Invio ] prima di attivare il file system principale. Ciò impedisce un avvio automatico.
Utilizzando una piccola partizione di un disco fisso, la richiesta di scambiare i dischetti non viene
più fatta.
383.4.1 File system /proc
Il fatto di utilizzare il dischetto in sola lettura impedisce il montaggio del file system ‘/proc/’
e di conseguenza i programmi ne risentono. Questo è il motivo principale per cui non si riesce a
realizzare questo dischetto con programmi derivanti da distribuzioni GNU/Linux recenti.
Capitolo
384
X-ISP
X-ISP a utilizza la libreria grafica XForms
appartiene al «software libero».
a
b
b
(‘libforms.so.*’). Questa libreria non
X-ISP GNU GPL, ma usa una libreria non libera
XForms software non libero, gratuito per uso «non commerciale»
X-ISP è un programma frontale (front-end) per la connessione PPP attraverso un modem, utilizzando in pratica il demone ‘pppd’. È facile da configurare ed è particolarmente adatto a chi si
trova impacciato nella realizzazione di uno script per questo scopo.
xisp
[opzioni]
Generalmente deve essere avviato con i privilegi dell’utente ‘root’. Se si vuole raggirare il problema, a discapito della sicurezza, per permettere il suo utilizzo anche agli utenti comuni, occorre
intervenire su alcuni file, dando i permessi di esecuzione per tutti i tipi di utente e attivando il bit
SUID. I file sono:
• ‘xisp’, collocato normalmente in ‘/usr/X11R6/bin/’;
• ‘xispdial’, collocato normalmente in ‘/usr/sbin/’.
Naturalmente, occorre intervenire anche su ‘/usr/sbin/pppd’, come era già stato descritto in
precedenza.
chmod a+x file
chmod u+s file
X-ISP permette di definire configurazioni differenti anche in funzione di possibili diversi ISP a
cui ci si collega. La configurazione avviene attraverso finestre di dialogo e non c’è la necessità di
agire manualmente all’interno di file.
La figura 384.1 mostra la maschera principale attraverso cui si controlla la connessione.
Figura 384.1. La maschera principale di X-ISP.
La configurazione del programma avviene attraverso le funzioni contenute nel menù Options. La
prima cosa da fare è dare un nome a una configurazione; la funzione si chiama ISP Selection e
4362
X-ISP
4363
in pratica si tratta di definire il nome dell’ISP a cui si abbinano le scelte che vengono fatte con le
voci successive.
La figura 384.2 mostra la maschera della funzione ‘Account Information’. In questa fase
viene indicato solo il modo con cui l’utente accede (il numero di telefono) e si fa riconoscere
dall’elaboratore remoto.
Attraverso X-ISP è possibile anche definire i segreti per un’autenticazione PAP e CHAP (anche se non si vede dalle figure). Negli esempio si mostra l’uso di X-ISP per un’autenticazione
tradizionale, manuale, attraverso l’uso di un terminale.
Figura 384.2. La maschera di definizione dell’accesso presso l’elaboratore remoto. In
questo caso, l’autenticazione PAP è disabilitata.
Se si usa un’autenticazione tradizionale, è possibile definire le coppie di attesa e invio per
automatizzare l’accesso, come si vede nella figura 384.3, dove viene mostrata la maschera
Dialing and Login con cui si possono determinare il numero di tentativi (in caso di mancata
risposta o di segnale di occupato) e il tipo di procedura di accesso: automatica o attraverso una
finestra di terminale.
Figura 384.3. La procedura di accesso può essere automatica, attraverso coppie di
attesa e invio, o manuale con una finestra di terminale. In questo caso si utilizza una
procedura di accesso manuale.
La maschera Communication Options permette di definire le caratteristiche della connessione
per quanto riguarda il rapporto tra l’elaboratore e il modem e tra il modem locale e quello remoto.
In particolare, la stringa di inizializzazione facoltativa dovrebbe contenere solo comandi ritenuti
essenziali, come nell’esempio mostrato in figura 384.4 in cui ci si limita a indicare ATX3. È
importante evitare di indicare comandi più drastici come sarebbe nel caso di ATZ, o peggio
X-ISP
4364
AT&F, perché ciò potrebbe annullare altre impostazioni particolari già definite da X-ISP.
Figura 384.4. La configurazione del modem.
Infine, restano da definire le opzioni della connessione TCP/IP. Difficilmente si riesce a ottenere
dal proprio ISP un indirizzo IP statico, di conseguenza, l’indirizzo locale e quello remoto restano azzerati in modo da permettere l’assegnazione dinamica. Generalmente, in una connessione
punto-punto, la maschera di rete dovrebbe essere 255.255.255.255. È importante ricordare di fare
in modo che l’instradamento verso l’elaboratore remoto diventi anche quello predefinito (defaultroute), altrimenti si resterebbe bloccati all’ambito della coppia costituita dall’elaboratore locale
e dall’elaboratore dell’ISP.
Figura 384.5. L’impostazione riferita alla connessione TCP/IP. Probabilmente è più
corretta una maschera di rete 255.255.255.255.
Con questo tipo di configurazione, quando ci si connette all’ISP, si ottiene una finestra di terminale, come nella figura 384.6, successivamente, al termine dell’autenticazione si deve fare un clic
sul pulsante di continuazione. Da quel momento la connessione è attivata fino a quando non si
conclude selezionando il pulsante D I S C O N N E C T dalla finestra di dialogo principale.
X-ISP
4365
Figura 384.6. Il terminale di X-ISP per la procedura di accesso manuale.
Capitolo
385
Introduzione a SMB con GNU/Linux
Questo capitolo nasce da esperienze dell’autore fatte nel 1997 e, oltre che essere obsoleti,
gli esempi mostrati ignorano completamente i problemi legati alla sicurezza. In tal senso,
eventualmente, questo capitolo può essere utile solo come punto di inizio per lo studio del
protocollo SMB.
SMB, o Session message block, è il protocollo di condivisione di risorse conosciuto normalmente
come NetBIOS o LanManager. Il protocollo NetBIOS può utilizzare diversi tipi di protocolli di
trasporto: NetBEUI, IPX/SPX e TCP/IP. In pratica, viene incapsulato all’interno di uno di questi.
È importante non confondere NetBIOS con NetBEUI: il primo è il protocollo di condivisione
di risorse, il secondo è un protocollo di trasporto.
GNU/Linux è in grado di offrire servizi NetBIOS attraverso il protocollo di trasporto TCP/IP e
questo per mezzo del gruppo di programmi denominato Samba. 1 La limitazione di GNU/Linux
nell’utilizzo del trasporto TCP/IP per questo scopo, deve essere tenuta presente nella configurazione degli elaboratori con cui si vuole comunicare attraverso NetBIOS (il trasporto NetBEUI
non va bene).
Samba fa ormai parte della maggior parte delle distribuzioni GNU/Linux. In questo capitolo si fa
riferimento a una versione di Samba installata attraverso una distribuzione, in modo tale che la
collocazione dei file sia conforme alle indicazioni del file system standard di GNU/Linux.
385.1 Nomi NetBIOS
Il protocollo NetBIOS viene usato per la condivisione di risorse. Quando lo si utilizza, è necessario identificare l’elaboratore che offre il servizio e la particolare risorsa desiderata. Sotto questo
aspetto, con NetBIOS non si parla di nodi, ma direttamente di serventi, clienti o peer.
Il nome che identifica una risorsa di un servente particolare, ha il formato seguente:
\\servente \risorsa
Il nome del servente e quello della risorsa non tengono conto della differenza tra lettere maiuscole
e minuscole.
Per esempio, ‘\\TIZIO\VARIE’ rappresenta la risorsa ‘VARIE’ dell’elaboratore ‘TIZIO’.
Quando si utilizza un servente SMB, come Samba, all’interno di un sistema Unix, i nomi di
dominio utilizzati per il trasporto IP non hanno niente a che vedere con i nomi NetBIOS, anche
se normalmente coincidono.
Quando si deve indicare un indirizzo del genere con una shell Unix, si ha quasi sempre la necessità di proteggere le barre oblique inverse da una diversa interpretazione. Lo si vedrà meglio
negli esempi descritti più avanti.
1
Samba GNU GPL
4366
4367
385.2 Trasporto TCP/IP
Come accennato, Samba comunica con NetBIOS attraverso il protocollo TCP/IP. Per questo, il
file ‘/etc/services’ deve contenere le righe seguenti.
netbios-ns
netbios-ns
netbios-dgm
netbios-dgm
netbios-ssn
137/tcp
137/udp
138/tcp
138/udp
139/tcp
nbns
nbns
nbdgm
nbdgm
nbssn
# NetBIOS Name Service
# NetBIOS Datagram Service
# NetBIOS session service
385.3 Servente SMB
Un servente SMB (o NetBIOS) permette di offrire la condivisione di parte del proprio file system,
come avviene con il protocollo NFS, e dei propri servizi di stampa. In pratica, esattamente quello
che si può fare con MS-Windows 3.11 e con le edizioni successive.
I servizi sono forniti da due demoni: ‘smbd’ e ‘nmbd’. Questi utilizzano il file ‘smb.conf’, collocato normalmente nella directory ‘/etc/’, per la loro configurazione. ‘smbd’ e ‘nmbd’ possono
essere avviati direttamente dalla procedura di inizializzazione del sistema (Init), oppure possono
essere messi sotto il controllo del supervisore dei servizi di rete. Nel primo caso, possono essere
avviati nel modo seguente:
# smbd -D
# nmbd -D
Se invece si intende utilizzare il controllo del supervisore dei servizi di rete, devono essere
presenti le righe seguenti nel file ‘/etc/inetd.conf’.
netbios-ssn
netbios-ns
stream
dgram
tcp
udp
nowait
wait
root
root
/usr/sbin/smbd smbd
/usr/sbin/nmbd nmbd
385.3.1 # nmbd
nmbd
[opzioni]
È il demone del servizio necessario per la gestione del name server ‘netbios’, per le connessioni SMB (Samba). A seconda di come è gestita la distribuzione GNU/Linux che si utilizza,
potrebbe essere avviato direttamente dalla procedura di inizializzazione del sistema, oppure dal
supervisore dei servizi di rete (capitolo 135).
Alcune opzioni
-D
Viene avviato come demone. Se non si usa questa opzione, il programma ‘nmbd’ funziona
in modo normale. Quando si utilizza ‘nmbd’ in uno script della procedura di inizializzazione
del sistema, si utilizza questa opzione.
4368
385.3.2 # smbd
smbd
[opzioni]
È il demone del servizio necessario per ricevere connessioni SMB (Samba). A seconda di come
è gestita la particolare distribuzione GNU/Linux che si utilizza, potrebbe essere avviato direttamente dalla procedura di inizializzazione del sistema, oppure dal supervisore dei servizi di rete
(capitolo 135).
Alcune opzioni
-D
Viene avviato come demone. Se non si usa questa opzione, il programma ‘smbd’ funziona
in modo normale. Quando si utilizza ‘smbd’ in uno script della procedura di inizializzazione
del sistema, si utilizza questa opzione.
385.3.3 Utente generico
Il protocollo NetBIOS viene usato spesso per condividere dischi e stampanti senza alcun controllo sugli utenti. Perché possa esistere questa possibilità anche con Samba, è necessario definire un
utente fittizio che verrà utilizzato come riferimento quando l’accesso avviene per servizi pubblici,
o anonimi.
Per questo, conviene aggiungere manualmente al file ‘/etc/passwd’ una riga simile a quella
seguente:
guestpc::499:100::/dev/null:/dev/null
Come si può vedere, si tratta di un utente senza parola d’ordine, senza directory personale e senza
shell.
È bene tenere presente che questa situazione, eventualmente, potrebbe essere pericolosa per
la sicurezza del sistema in generale e, comunque, il fatto di mettere a disposizione un accesso
del genere manifesta l’intenzione di non curarsi di questi problemi.
Il nome ‘guestpc’ è scelto in base al valore predefinito da Samba per questo scopo. In altre
situazioni potrebbe anche corrispondere al tipico utente ‘nobody’. Il numero usato come UID
va scelto in modo che non coincida con altri contenuti all’interno del file ‘/etc/passwd’ (a
meno che si sappia ciò che si intende fare); per quanto riguarda la scelta del GID (il numero del
gruppo), questo dipende dalle particolari strategie adottate nella gestione degli utenti.2
385.3.4 Directory condivisa
Così come si utilizza un utente particolare per gli accessi non controllati, è opportuno predisporre
una directory a disposizione di tutti, attribuendole tutti i permessi necessari. Trattandosi di uno
spazio nel file system abbinato a un utente, anche se fittizio, è ragionevole collocare i file e le
directory da condividere pubblicamente a partire da ‘/home/samba/’.
# mkdir /home/samba
# chmod a+rwx /home/samba
2
Per esempio, potrebbe essere abbinato a un gruppo omonimo ‘guestpc’, o simile.
4369
385.3.5 Coda di stampa
Per soddisfare le richieste di stampa, è necessaria la presenza di una coda, costituita da una
directory. Normalmente si tratta di ‘/var/spool/samba/’. Anche in questo caso, non si devono
porre restrizione nei permessi.
# mkdir /var/spool/samba
# chmod a+rwx /var/spool/samba
385.3.6 /etc/smb.conf
La configurazione attraverso ‘/etc/smb.conf’ è delicata. Negli esempi seguenti si propone il minimo necessario a condividere pubblicamente uno spazio su disco e una stampante.
Solitamente, le distribuzioni propongono un file più completo e ben commentato.
; =====================================================================
; /etc/smb.conf
; =====================================================================
;
[global]
allow hosts = 192.168.1.0/255.255.255.0
workgroup = UFFICIO
guest account = guestpc
printing = bsd
printcap name = /etc/printcap
[public]
comment = directory pubblica
path = /home/samba
public = yes
writable = yes
printable = no
browseable = yes
[lp]
comment = stampante pubblica
path = /var/spool/samba
public = yes
writable = no
printable = yes
browseable = yes
[global]
La sezione ‘global’ è speciale e serve per stabilire i valori predefiniti per tutte le altre
sezioni.
allow hosts = indirizzo_ip /maschera
Permette di definire i nodi che possono accedere ai servizi di Samba. In questo caso si
concede a tutta la sottorete 192.168.1.0 di accedere.
workgroup = nome_del_gruppo
Permette di definire il nome del gruppo di lavoro. Il valore predefinito, nel caso non sia
indicato, dovrebbe essere ‘WORKGROUP’ a seconda di come è stato compilato il sorgente.
guest account = utente_guest
Permette di definire il nome di un utente generico, al quale è consentito utilizzare i servizi
pubblici. Questo utente era stato aggiunto al file ‘/etc/passwd’ (385.3.3).
4370
printing = bsd
Assegnando a questa variabile il valore ‘bsd’ si informa Samba che il sistema di stampa
utilizza il programma ‘lpr’.
printcap name = file_printcap
Il nome del file ‘/etc/printcap’, completo del percorso.
[public]
Si tratta della definizione di un servizio denomianto ‘public’ creato per permettere
l’accesso indiscriminato alla directory ‘/home/samba’.
comment = commento
Si tratta della descrizione del servizio.
path = percorso_della_directory
È il percorso della directory pubblica. Perché possa essere disponibile veramente a tutti,
occorre che i suoi permessi di accesso consentano tutte le operazioni a tutti gli utenti.
public =
{yes|no}
Permette di definire se si tratta o meno di un servizio pubblico.
writable =
{yes|no}
Permette di definire se gli utenti di questo servizio possono accedere anche in scrittura.
printable =
{yes|no}
Permette di definire se si tratta di un servizio di stampa. In questo caso, evidentemente no.
[lp]
Si tratta della definizione di un servizio denomianto ‘lp’ creato per permettere l’accesso
indiscriminato alla stampante omonima (‘lp’) del file ‘/etc/printcap’. In pratica rende
pubblica, attraverso Samba, questa stampante.
path = percorso_della_directory
Definisce il percorso della directory che Samba userà per accodare le stampe. Non si deve
confondere questa directory con quelle già utilizzate con il sistema di stampa normale,
questo perché si deve trattare di una directory accessibile a tutti.
public =
{yes|no}
Permette di definire se si tratta o meno di un servizio pubblico.
writable =
{yes|no}
Permette di definire se gli utenti di questo servizio possono accedere anche in scrittura. In
questo caso no, trattandosi di un servizio di stampa.
printable =
{yes|no}
Permette di definire se si tratta di un servizio di stampa.
4371
385.3.7 Verifica del funzionamento
Per controllare la correttezza sintattica del file di configurazione ‘/etc/smb.conf’ si può
utilizzare il programma ‘testparm’.
$ testparm[ Invio ]
Si dovrebbe ottenere un elenco suddiviso in due parti. Segue solo la prima parte.
Load smb config files from /etc/smb.conf
Processing section "[public]"
Loaded services file OK.
Press enter to see a dump of your service definitions
Premendo [ Invio ] si ottiene il resto delle informazioni che riguardano la configurazione, così
come è stata interpretata, completa di tutti i valori predefiniti.
Il passo successivo è quello di controllare che il servizio sia funzionante effettivamente. Se l’elaboratore che si utilizza e sul quale è installato Samba, si chiama dinkel.brot.dg, si può
utilizzare il programma ‘smbclient’ nel modo seguente:
$ smbclient -L dinkel.brot.dg[ Invio ]
Si dovrebbe ottenere il risultato seguente:
Added interface ip=192.168.1.1 bcast=192.168.1.255 nmask=255.255.255.0
Server time is Wed Apr 9 10:47:46 1997
Timezone is UTC+1.0
Domain=[UFFICIO] OS=[Unix] Server=[Samba 1.9.16p11]
Server=[dinkel] User=[daniele] Workgroup=[UFFICIO] Domain=[UFFICIO]
Sharename
--------IPC$
lp
public
Type
---IPC
Printer
Disk
Comment
------IPC Service (Samba 1.9.16p11)
stampante pubblica
directory pubblica
This machine has a browse list:
Server
--------DINKEL
Comment
------Samba 1.9.16p11
This machine has a workgroup list:
Workgroup
--------UFFICIO
Master
------DINKEL
385.3.8 Nome del servente secondo NetBIOS
Attraverso ‘smbclient’ è possibile, tra l’altro, conoscere la situazione di un servente SMB.
In particolare è importante osservare il nome secondo NetBIOS, ovvero quello indicato come
servente. Nell’esempio visto in precedenza si otteneva tra l’altro la riga seguente:
Server=[dinkel] User=[daniele] Workgroup=[UFFICIO] Domain=[UFFICIO]
Ecco che in questo esempio, il nome NetBIOS dell’elaboratore è ‘dinkel’. La coincidenza con
il nome utilizzato per il trasporto IP è dovuta a Samba che utilizza la parte finale del nome di
4372
dominio per questo. Il punto è però che tale assunto non deve essere considerato la regola; infatti,
questo nome può essere cambiato.
385.3.9 $ smbstatus
smbstatus
[opzioni]
‘smbstatus’ è un programma molto semplice che permette di conoscere le connessioni in corso
al servente SMB locale. Di solito non si usano opzioni.
Esempi
$ smbstatus[ Invio ]
Samba version 1.9.16p11
Service
uid
gid
pid
machine
---------------------------------------------public
guestpc users
148
roggen (192.168.1.2) Wed Apr
9 15:05:44 1997
No locked files
In questo caso, c’è un solo accesso al servizio pubblico ‘public’ da parte dell’elaboratore
‘roggen’.
385.4 Cliente SMB
Samba consente di accedere a un servente SMB, ovvero a un elaboratore che offre servizi NetBIOS. Ciò viene fatto fondamentalmente attraverso il programma ‘smbclient’ che si comporta
in modo simile a un cliente per FTP, anche se non si tratta proprio della stessa cosa.
385.4.1 $ smbclient
smbclient servente_e_servizio
[parola_d’ordine] [opzioni]
smbclient -L host
‘smbclient’ è il programma attraverso cui è possibile connettersi a un elaboratore che offre ser-
vizi NetBIOS attraverso il protocollo TCP/IP. Potrebbe trattarsi di MS-Windows 95/98/NT/2000
o anche di un altro elaboratore GNU/Linux che gestisce un servente SMB con Samba.
In linea di massima, si può vedere questo programma come una sorta di cliente FTP, con la
differenza che si può inviare un file anche a un servizio di stampa. In questo senso, il programma
offre normalmente un invito attraverso il quale possono essere impartiti dei comandi. Questo
invito è ‘smb \>’, dove la barra obliqua inversa rappresenta la directory corrente della risorsa a
cui ci si è connessi (in questo caso è la radice).
L’indicazione del servente e della risorsa deve essere fatto nella forma consueta.
\\servente \risorsa
Alcune opzioni
-P
Inizia una connessione a una risorsa di stampa, invece che alla solita risorsa di condivisione
di file.
-L host
4373
Permette di ottenere la lista delle risorse ottenibili da un elaboratore determinato. In tal
caso, l’elaboratore viene identificato attraverso i comuni indirizzi IP o i nomi di dominio.
-c stringa_di_comando
Permette di indicare una stringa di comando da eseguire. In questo modo si evita la modalità
interattiva perché si indica tutto quello che si vuole ottenere nella stringa. per indicare più
comandi, questi devono essere separati con il punto e virgola (‘;’).
-I host
Permette di definire l’indirizzo (numero IP, oppure il nome di dominio) dell’elaboratore
che concede il servizio. Solitamente, l’indirizzo viene ottenuto attraverso una chiamata
circolare (broadcast), ma ci sono situazioni in cui questo sistema non può funzionare, per
esempio quando si attraversa un router.
Esempi
$ smbclient -L dinkel.brot.dg
Richiede e ottiene
dinkel.brot.dg.
l’elenco
delle
risorse
SMB
disponibili
nell’elaboratore
$ smbclient ’\\mais\c’
Attiva una connessione con la risorsa di condivisione file ‘c’ dell’elaboratore identificato
dal protocollo NetBIOS con il nome ‘mais’. Non avendo indicato esplicitamente la parola
d’ordine, questa viene richiesta prima di presentare l’invito di ‘smbclient’: se per questa
risorsa non è prevista, basta lasciarla in bianco e premere [ Invio ].
$ smbclient ’\\mais\c’ -I 192.168.1.15
Come nell’esempio precedente, ma viene specificato l’indirizzo IP del servente.
$ smbclient ’\\mais\stampa’ -P
Attiva una connessione con la risorsa di condivisione della stampante ‘stampa’ dell’elaboratore identificato dal protocollo NetBIOS con il nome ‘mais’. Non avendo indicato
esplicitamente la parola d’ordine, questa viene richiesta prima di presentare l’invito di
‘smbclient’: se per questa risorsa non è prevista, basta lasciarla in bianco e premere
[ Invio ].
$ smbclient ’\\mais\stampa’ "" -P -c "print ./lettera"
Come nell’esempio precedente, attiva una connessione con la risorsa di condivisione della
stampante ‘stampa’, ma indica già la parola d’ordine, corrispondente alla stringa nulla, e
il comando da eseguire: ‘print ./lettera’. In questo modo, non inizia alcuna sessione
interattiva e il programma procede immediatamente all’invio del file ‘./lettera’ per la
stampa.
385.4.2 Verificare il funzionamento di un servente Samba
In precedenza si è visto come realizzare un servente SMB attraverso Samba. Per verificarne il
funzionamento attraverso il programma ‘smbclient’ si può tentare un collegamento. Ciò può
essere fatto sia dallo stesso elaboratore che offre il servizio che da un altro.
$ smbclient ’\\DINKEL\PUBLIC’[ Invio ]
Il nome dell’elaboratore e quello della risorsa sono scritti con lettere maiuscole intenzionalmente,
non perché ciò sia necessario, ma perché è possibile. Infatti, molti clienti di servizi NetBIOS sono
in grado di utilizzare solo nomi composti da lettere maiuscole.
4374
Si osservi l’uso degli apici singoli. L’indicazione dell’elaboratore e della directory è fatta di
due barre oblique inverse, seguite dal nome dell’elaboratore, seguito da una barra obliqua
inversa, seguita dal nome dell’oggetto condiviso. Se fossero stati utilizzati gli apici doppi, con
la shell Bash o altra simile, le barre oblique avrebbero dovuto essere raddoppiate.
In base all’esempio di configurazione presentato all’inizio di questo capitolo, il risultato dovrebbe
essere quello seguente:
Server time is Wed Apr 9 11:00:13 1997
Timezone is UTC+1.0
Password:
Dal momento che si fa riferimento a un servizio pubblico, non si inserisce alcuna parola d’ordine:
si preme semplicemente [ Invio ].
Domain=[UFFICIO] OS=[Unix] Server=[Samba 1.9.16p11]
smb: \>
A questo punto, ‘smbclient’ si comporta come un programma di FTP. Per terminare
l’esecuzione di ‘smbclient’ è sufficiente scrivere il comando ‘quit’.
385.5 Connessione con una rete NetBIOS-TCP/IP
Per poter integrare il proprio elaboratore GNU/Linux, sul quale è appena stato installato Samba,
con una rete che utilizza NetBIOS, occorre che i sistemi operativi di questa rete utilizzino il
trasporto TCP/IP.3
Di conseguenza, si potrà interagire con sistemi MS-Windows 95/98/NT/2000, mentre per MSWindows 3.11 e per il Dos occorre aggiungere l’estensione al TCP/IP. Per questo scopo si può
visitare eventualmente il seguente indirizzo.
<ftp://ftp.microsoft.com/bussys/clients/>
L’esempio seguente mostra l’interrogazione di un elaboratore su cui gira MS-Windows
95/98/NT/2000 che consente la condivisione del disco ‘C:’ e della stampante.
$ smbclient -L roggen.brot.dg[ Invio ]
Server time is Thu Apr 10 12:50:16 1997
Timezone is UTC+2.0
Server=[ROGGEN] User=[] Workgroup=[UFFICIO] Domain=[UFFICIO]
Sharename
--------C
HP
IPC$
PRINTER$
Type
---Disk
Printer
IPC
Disk
Comment
-------
Comunicazioni remote tra processi
Da quello che si vede nell’elenco dei servizi è possibile utilizzare ‘smbclient’ per accedere alla
risorsa ‘C’.
$ smbclient ’\\ROGGEN\C’
3
Di solito, le reti NetBIOS fanno uso del protocollo di trasporto NetBEUI che ha il vantaggio di non richiedere alcuna
configurazione. L’utilizzo del trasporto TCP/IP obbliga a indicare gli indirizzi IP e le maschere di rete. Ciò significa
che, oltre a dover pianificare i nomi dei serventi o peer, si devono organizzare anche gli indirizzi IP. Di solito, questo
particolare viene dimenticato perché non sembra fare parte del protocollo NetBIOS.
4375
Dal lato dell’elaboratore roggen.brot.dg sul quale è in funzione MS-Windows
95/98/NT/2000, è possibile utilizzare le risorse di rete per accedere all’elaboratore GNU/Linux
(dinkel.brot.dg), sempre che questo abbia attivato un servente SMB con Samba.
Figura 385.1. La directory pubblica amministrata da Samba, dal punto di vista di MSWindows 95/98/NT/2000.
Dal lato dell’elaboratore GNU/Linux è possibile controllare gli accessi attraverso ‘smbstatus’.
$ smbstatus[ Invio ]
Samba version 1.9.16p11
Service
uid
gid
pid
machine
---------------------------------------------public
guestpc users
148
roggen (192.168.1.2) Wed Apr
9 15:05:44 1997
No locked files
Segue il contenuto delle directory pubbliche così come si vede in figura 385.1 dal punto di vista
di GNU/Linux.
total 55
-rwxr--r--rwxr--r--rwxr--r--rwxr--r--
1
1
1
1
guestpc
guestpc
guestpc
guestpc
users
users
users
users
49129
3236
476
261
Feb 1 1992 dc.com
Feb 1 1992 dc.doc
Feb 6 20:46 dc.ext
Dec 12 20:40 dc.mnu
Per utilizzare una stampante condivisa in una rete NetBIOS, si può utilizzare ancora
‘smbclient’. Per esempio, si vuole stampare il file ‘esempio’ nella stampante condivisa con il
nome ‘HP’ dall’elaboratore ‘roggen’.
$ smbclient ’\\ROGGEN\HP’ -P
Dopo la richiesta della parola d’ordine, che supponiamo sia inesistente, si presenta l’invito di
‘smbclient’ dal quale è possibile dare il comando di stampa.
print file_da_stampare
Quindi si può uscire dalla sessione di lavoro con ‘smbclient’ utilizzando il comando ‘quit’.
Di certo è un’operazione piuttosto laboriosa, inoltre si aggiunge il problema della scalettatura,
cioè la necessità di convertire i file di testo Unix in file di testo Dos.
4376
385.5.1 Cliente MS-Dos
Se si vogliono utilizzare elaboratori MS-Dos per accedere a elaboratori GNU/Linux che condividono dati attraverso Samba, è necessario acquisire il software ‘msclient’ dal solito indirizzo
di Microsoft.
<ftp://ftp.microsoft.com/bussys/clients/>
Nell’elaboratore Dos, una volta decompressi i file in una directory transitoria, si può avviare il
programma ‘SETUP.EXE’. È necessario solo il protocollo TCP/IP, mentre il NetBEUI è superfluo e serve solo a ridurre ulteriormente la scarsa memoria a disposizione. È anche sufficiente
utilizzare il cosiddetto redirector di base.
Solitamente, il cliente Microsoft viene installato in ‘C:\NET’ Al suo interno sono disponibili
alcuni file di configurazione ‘.INI’, secondo la convenzione normale di MS-Windows. Tutto,
o quasi, è configurabile attraverso il programma ‘SETUP.EXE’, anche se resta la possibilità di
modificare direttamente questi file.
Quello che segue è un esempio del file ‘PROTOCOL.INI’.
[network.setup]
version=0x3110
netcard=ms$ne2clone,1,MS$NE2CLONE,1
transport=tcpip,TCPIP
lana0=ms$ne2clone,1,tcpip
[TCPIP]
NBSessions=6
SubNetMask0=255 255 255 0
IPAddress0=192 168 1 10
DisableDHCP=1
DriverName=TCPIP$
BINDINGS=MS$NE2CLONE
LANABASE=0
[MS$NE2CLONE]
IOBASE=0x300
INTERRUPT=10
DriverName=MS2000$
[protman]
DriverName=PROTMAN$
PRIORITY=MS$NDISHLP
È importante osservare il modo con cui viene inserito l’indirizzo IP dell’elaboratore, cioè separando gli ottetti attraverso spazi invece che con il consueto punto. È importante impostare
correttamente la maschera di rete e disabilitare il DHCP, ‘DisableDHCP=1’, a meno che questo
ultimo sia disponibile effettivamente.
Quello che segue è un esempio del file ‘SYSTEM.INI’.
[network]
filesharing=no
printsharing=no
autologon=yes
computername=ALFA
lanroot=C:\NET
username=DANIELE
workgroup=UFFICIO
reconnect=yes
dospophotkey=N
lmlogon=0
logondomain=UFFICIO
preferredredir=basic
autostart=basic
4377
maxconnections=8
[network drivers]
netcard=ne2000.dos
transport=tcpdrv.dos,nemm.dos
devdir=C:\NET
LoadRMDrivers=yes
[386enh]
TimerCriticalSection=5000
UniqueDosPSP=TRUE
PSPIncrement=2
[Password Lists]
*Shares=C:\NET\Shares.PWL
DANIELE=C:\NET\DANIELE.PWL
È abbastanza importante che il gruppo di lavoro (workgroup) sia uguale a quello del servizio da raggiungere, anche se non è indispensabile. In questo caso: ‘workgroup=UFFICIO’.
Inoltre, per risparmiare memoria, è conveniente che sia attivato solo il redirector di base:
‘preferredredir=basic’.
385.5.2 Problemi con i router
Quando si utilizzano clienti NetBIOS come MS-Windows 95/98/NT/2000 o lo stesso MS-Dos,
pur avendo la possibilità di indicare l’indirizzo di un router (gateway), normalmente non si riesce
ad attraversarlo per accedere a un servizio NetBIOS che si trovi oltre questo.
Ciò dipende dalla normale impossibilità di indicare il nodo di destinazione attraverso la notazione necessaria al protocollo IP. In pratica, il cliente tipico effettua un’interrogazione circolare
(broadcast) per il servente che offre un servizio NetBIOS particolare. La risposta si ottiene regolarmente se il servente è connesso nella stessa rete o sottorete, mentre non si ottiene alcuna
risposta se questo si trova oltre un router.
I programmi cliente di GNU/Linux, come ‘smbclient’ e ‘smbmount’ (il secondo viene descritto
più avanti), offrono la possibilità di indicare esplicitamente l’indirizzo del nodo che funge da
servente NetBIOS. In tal modo, questi clienti riescono ad attraversare anche i router.
385.6 Stampa
Come si è visto, la stampa attraverso un servizio SMB avviene per mezzo di ‘smbclient’.
La maggior parte delle distribuzioni GNU/Linux predispone già un sistema di filtri di stampa
completo anche della possibilità di stampare presso una stampante remota di tipo SMB.
A titolo di esempio, si può osservare lo script seguente che si occupa di ricevere lo standard input
e di inviarlo, tramite ‘smbclient’, a una stampante remota particolare. Per farlo, viene creato
un file temporaneo nella directory personale dell’utente che lo utilizza, che con l’occasione viene
trasformato. In questo esempio, ci si limita a fare in modo che il codice di interruzione di riga
corrisponda alla sequenza <CR><LF>, adatta alle stampanti comuni.4
#!/bin/bash
#======================================================================
# stampa-smb
#
# Esempio di una sorta di filtro di stampa per utilizzare una stampante
# condivisa da un servente SMB.
4
Qui si intende che il programma ‘unix2dos’ si comporti come filtro, ricevendo i dati dallo standard input ed
emettendo il risultato della sua elaborazione attraverso lo standard output.
4378
#======================================================================
#======================================================================
# Variabili.
#======================================================================
#-----------------------------------------------------------------# Il nome del file temporaneo da utilizzare per la stampa.
#-----------------------------------------------------------------STAMPA="$HOME/stampa-smb-$(date +%Y%m%d%H%M%S)"
#-----------------------------------------------------------------# Il nome del servizio di stampa SMB.
#-----------------------------------------------------------------SMB_PRINT=’\\weizen.mehl.dg\lp’
#======================================================================
# Inizio.
#======================================================================
#-----------------------------------------------------------------# Scarica lo standard input nel file temporaneo, trasformandolo
# in un testo «Dos» in cui «newline» corrisponda alla sequenza
# <CR><LF>.
#-----------------------------------------------------------------cat | unix2dos > $STAMPA
#-----------------------------------------------------------------# Invia il file a un servizio di stampa SMB.
#-----------------------------------------------------------------smbclient $SMB_PRINT "" -P -c "print $STAMPA" > /dev/null
#-----------------------------------------------------------------# Elimina il file transitorio.
#-----------------------------------------------------------------rm $STAMPA > /dev/null
#======================================================================
# Fine.
#======================================================================
385.7 Montare una risorsa di condivisione dei file nel
file system GNU/Linux
Finora si è visto che è possibile accedere a una directory condivisa con il protocollo NetBIOS
attraverso il programma ‘smbclient’. Ma questo programma non consente di montare quella
directory, così come si fa con il protocollo NFS. Per questo occorre predisporre il kernel (nella sezione dedicata ai file system, 29.2.14) e per il montaggio si deve utilizzare il programma
‘smbmount’. Nella configurazione del kernel conviene attivare anche la gestione del raggiro del
problema delle prime versioni di MS-Windows 95.
385.7.1 $ smbmount
smbmount servizio punto_di_innesto
[opzioni]
‘smbmount’ permette di eseguire il montaggio di una directory offerta in condivisione da un
servizio NetBIOS. Il nome del servizio viene indicato in maniera più confacente allo standard
Unix, utilizzando barre inclinate normali e non inverse come richiede normalmente NetBIOS. Il
servizio ha la sintassi seguente:
[
]
//servente /risorsa /directory
4379
In questo modo si indica il servente e il nome della risorsa, come al solito, a parte l’uso delle barre
normali. Di seguito, si può aggiungere l’indicazione di una directory particolare, discendente da
quella di partenza per il servizio indicato.
‘smbmount’ può essere utilizzato eventualmente anche da utenti comuni (diversi dall’utente
‘root’), ma in tal caso, deve essere attivato il bit SUID (SUID-root). In pratica, deve avere i
permessi 47558 e appartenere all’utente ‘root’.
Alcune opzioni
-s servente
In alcune circostanze è necessario specificare a parte il nome del servente NetBIOS e questa
opzione permette di farlo.
-c cliente
In alcune circostanze è necessario specificare a parte il nome del cliente NetBIOS, cioè di
se stessi, attraverso questa opzione.
-U utente
Permette di specificare un nome di utente, per gli scopi di NetBIOS, diverso da quello
utilizzato effettivamente nell’elaboratore cliente.
-I host
Permette di definire l’indirizzo (numero IP, oppure il nome di dominio) dell’elaboratore che
concede il servizio. Solitamente, questo indirizzo viene ottenuto attraverso una chiamata
circolare (broadcast), ma ci sono situazioni in cui questo sistema non può funzionare, per
esempio quando si attraversa un router.
-u utente
-g gruppo
Queste due opzioni permettono di definire la proprietà dei file e delle directory del file system che viene montato. Infatti, trattandosi di un file system sprovvisto di tali informazioni,
è necessario decidere a chi si vuole fare appartenere il suo contenuto. Se non si utilizzano
queste opzioni, tutto è di proprietà dell’utente ‘root’.
Esempi
$ smbmount //W5/C /mnt/dosserver
Esegue il montaggio della directory condivisa dal servente NetBIOS ‘W5’ con il nome ‘C’,
utilizzando come punto di innesto ‘/mnt/dosserver/’. I dati ottenuti (file e directory)
risulteranno appartenere all’utente ‘root’.
$ smbmount //W5/C /mnt/dosserver -c linux1
Esegue la stessa operazione dell’esempio precedente, ma fa in modo che l’elaboratore locale (il cliente dal quale si esegue il montaggio) venga identificato, ai fini del protocollo
NetBIOS, con il nome ‘linux1’.
$ smbmount //W5/C /mnt/dosserver -c linux1 -I 192.168.2.15
Come nell’esempio precedente, ma indica esplicitamente l’indirizzo IP del nodo cui corrisponde il nome NetBIOS ‘W5’. Ciò permette di superare un eventuale router e comunque
evita una richiesta circolare a tutta la rete.
$ smbmount //W5/C /mnt/dosserver -u daniele -g daniele
Come nel primo esempio, ma viene indicato a quale utente e gruppo devono risultare
appartenenti i file e le directory.
4380
385.7.2 $ smbumount
smbumount punto_di_innesto
‘smbumount’ permette agli utenti comuni di smontare una directory offerta in condivisione da
un servizio NetBIOS, montata precedentemente con ‘smbmount’. Perché ciò possa funzionare,
è necessario che questo programma appartenga all’utente ‘root’ e abbia il bit SUID attivato
(SUID-root). In pratica, le stessa situazione richiesta per ‘smbmount’.
L’utente ‘root’ non ha bisogno di utilizzare questo programma; per lui è sufficiente il solito
‘umount’.
385.8 Riferimenti
• David Wood, SMB HOWTO
<http://www.linux.org/docs/ldp/howto/HOWTO-INDEX/howtos.html>
Capitolo
386
Applicazioni multimediali
In questo capitolo si raccolgono informazioni su applicativi multimediali che per qualche motivo
non vengono più seguite in questo documento.
386.1 Wavplay
Wavplay 1 è un pacchetto per l’esecuzione e la registrazione di file audio in formato WAV-RIFF.
Non si tratta di qualcosa di eccezionale, ma è almeno uno strumento funzionale che permette di
non dover lavorare direttamente con i file di dispositivo.
Purtroppo, Wavplay non funziona con tutti i tipi di scheda audio. In generale dovrebbe andare
bene con quelle i cui driver appartengono alla serie «OSS».
386.1.1 $ wavplay, wavrec
[opzioni] file_wav ...
wavrec [opzioni] file_wav
wavplay
Come si può intuire, ‘wavrec’ registra, mentre ‘wavplay’ esegue i file WAV. Le opzioni di questi
due programmi eseguibili sono in parte uguali.
Alcune opzioni
-s frequenza_campionamento
In registrazione permette di definire la frequenza di campionamento. Il valore predefinito
è di 22050 Hz. Utilizzando frequenze maggiori si migliora la qualità della registrazione,
aumentando proporzionalmente le dimensioni del file che si genera.
In esecuzione, permette di modificare la velocità di ascolto. In pratica, utilizzando una
frequenza di campionamento inferiore a quella utilizzata per registrare si ottiene un’esecuzione rallentata e, di conseguenza, il contrario aumentando la frequenza. In generale, per
eseguire un brano alla sua velocità naturale, non occorre specificare questa opzione.
-S
Richiede espressamente una registrazione o un’esecuzione stereofonica.
-M
Richiede espressamente una registrazione o un’esecuzione monofonica.
|
-b 8 16
Permette di specificare espressamente la dimensione in bit di ogni campione. Si può
scegliere solo tra i valori 8 e 16.
-t n_secondi_registrazione
Permette di fissare la durata della registrazione (non si usa per l’esecuzione).
-i
Riguarda solo ‘wavplay’ e fa sì che si limiti a mostrare le caratteristiche del file, senza
eseguirlo.
1
Wavplay GNU GPL
4381
4382
Esempi
$ wavrec -b 8 -S -t 60 mio_file.wav
Registra nel file ‘mio_file.wav’ ciò che proviene dalla scheda audio (si deve utilizzare un
programma come Aumix per selezionare un segnale in registrazione), con campioni di 8 bit,
in stereofonia, per una durata di 60 s. La frequenza di campionamento è quella predefinita.
$ wavrec -b 8 -S -t 60 -s 20000 mio_file.wav
Come nell’esempio precedente, specificando una frequenza di campionamento di
20000 Hz.
$ wavplay mio_file.wav
Esegue il file ‘mio_file.wav’.
$ wavplay -s 10000 mio_file.wav
Esegue il file ‘mio_file.wav’ a una data frequenza di campionamento, in modo da
alterarne la velocità di esecuzione (seguendo gli esempi già visti, la velocità viene
dimezzata).
386.1.2 $ xltwavplay
Wavplay si compone anche dell’eseguibile ‘xltwavplay’, a volte distribuito in un pacchetto
separato, che si comporta da programma frontale grafico per ‘wavplay’ e ‘wavrec’. In pratica,
utilizza il sistema grafico X per comandare ‘wavplay’ e ‘wavrec’ in modo più gradevole rispetto
alla solita riga di comando.
Figura 386.1. Aspetto del programma frontale di Wavplay.
4383
L’unico problema di ‘xltwavplay’ sta nel fatto che utilizza le librerie LessTif che funzionano
ancora perfettamente.
386.2 Mpg123
Mpg123 2 è un applicativo specializzato per l’esecuzione di brani memorizzati in formato MP3.
Mpg123 si compone in pratica solo dell’eseguibile omonimo: ‘mpg123’.
mpg123
[opzioni] {file_mp3|uri_http}
L’eseguibile in questione è ricco di opzioni e di possibilità; tuttavia dovrebbe bastare l’indicazione del file MP3 come unico argomento per iniziare la sua esecuzione attraverso la gestione dell’audio del sistema operativo (in pratica si arrangia a inviare i dati al dispositivo ‘/dev/audio’
o ‘/dev/dsp’, che deve avere i permessi necessari).
Una particolarità di Mpg123 è quella di poter caricare direttamente un file attraverso il protocollo
HTTP. Per esempio:
$ mpg123 mio_file.mp3
avvia l’esecuzione del file ‘mio_file.mp3’, mentre:
$ mpg123 "http://www.brot.dg/brano.mp3"
esegue direttamente il file che si ottiene dall’URI ‘http://www.brot.dg/brano.mp3’. Eventualmente, per questo è possibile servirsi anche di un proxy. Per maggiori dettagli si può
consultare la pagina di manuale relativa: mpg123(1).
386.3 8Hz-mp3
8Hz-mp3 3 è un programma che è stato disponibile gratuitamente, ma che pare avere qualche
problema (si veda a questo proposito <http://www.8hz.com/mp3/index.html> ed eventualmente anche
<http://sound.media.mit.edu/~eds/mpeg-patents-faq>). 8Hz-mp3 è in grado di convertire file WAV-RIFF,
o PCM, in MP3. In generale, conviene limitarsi alla conversione a partire da file WAV-RIFF,
dal momento che questi contengono nell’intestazione tutte le informazioni necessarie a conoscere il modo in cui sono campionati. L’eseguibile ‘8hz-mp3’ è tutto ciò che compone questo
programma:
8hz-mp3
[opzioni]
file_in_ingresso file_mp3_generato
L’uso normale di 8Hz-mp3 non richiede alcuna opzione. Per la precisione, senza opzioni, 8Hzmp3 si aspetta che il file in ingresso sia in formato WAV-RIFF, generando un file MP3 con la
qualità migliore che è in grado di ottenere.
Alcune opzioni
-c
Imposta nel file MP3 il bit ‘copyright’. Senza questa opzione, il bit non viene attivato.
-o
Imposta nel file MP3 il bit ‘original’. Senza questa opzione, il bit non viene attivato.
-q n_qualità
2
3
Mpg123 software non libero: non è consentita la modifica e la commercializzazione
8Hz-mp3 gratuito, senza una licenza vera e propria
4384
Definisce esplicitamente il livello di qualità che si intende ottenere nel file MP3. Il valore
predefinito è zero, che corrisponde alla qualità migliore. Valori superiori allo zero, fino a
un massimo di 30, indicano qualità progressivamente inferiori.
Esempi
$ 8hz-mp3 01.wav 01.mp3
Converte il file ‘01.wav’ nel file ‘01.mp3’, utilizzando le impostazioni predefinite.
$ for i in *.wav ; do 8hz-mp3 $i $i.mp3 ; done
Attraverso la shell, attiva un ciclo con il quale vengono convertiti tutti i file che terminano
con estensione ‘.wav’ in MP3, creando altrettanti file, che si distinguono perché hanno in
più l’estensione ‘.mp3’.
386.4 Xanim
Xanim 4 è un programma, apparentemente molto semplice, che permette la visione e l’ascolto
di file contenenti delle animazioni. I formati che può gestire sono molti; per citarne alcuni: FLI,
GIF animati, AVI e Quicktime. Xanim (l’eseguibile ‘xanim’) può essere usato molto bene in
modo non interattivo attraverso l’uso delle opzioni fornite nella riga di comando, ma permette
comunque una gestione intuitiva anche senza di queste. L’unico argomento obbligatorio è il nome
del file che si vuole «eseguire».
Per utilizzare bene Xanim è necessario leggere la pagina di manuale xanim(1).
386.4.1 $ xanim
xanim
[opzioni]
file ...
Come accennato, ‘xanim’ richiede espressamente l’indicazione di almeno un file di animazione
da eseguire. Se vengono indicati più file, questi risultano uniti assieme in un’unica sequenza.
Il controllo dell’esecuzione delle animazioni avviene normalmente attraverso un pannellino di
controllo che si può vedere nella figura 386.2.
Figura 386.2. La finestra contenente il pannellino di controllo di Xanim.
Anche senza volere approfondire l’uso di questo programma, può essere conveniente conoscere almeno l’uso del mouse e di alcune funzionalità della tastiera durante l’esecuzione di
un’animazione:
• facendo un clic con il primo tasto del mouse, oppure premendo il tasto [ , ] (virgola), si
ottiene l’arresto dell’esecuzione e la visualizzazione della scena precedente;
• facendo un clic con il terzo tasto del mouse, oppure premendo il tasto [ . ] (punto), si ottiene
l’arresto dell’esecuzione e la visualizzazione della scena successiva;
4
Xanim software gratuito, non libero, per uso «non commerciale»
4385
• facendo un clic con il secondo tasto del mouse (quello centrale) si ottiene la ripresa
dell’esecuzione dell’animazione (se era stata fermata);
• la [ barra spaziatrice ] arresta o fa riprendere l’esecuzione dell’animazione;
Capitolo
387
Acua
Un sistema dedicato prevalentemente agli utenti, sul quale possano accedere un gran numero di
persone, richiede la definizione di una regolazione di tali accessi, in base alle politiche che si
vogliono attuare. In tali situazioni di affollamento è importante poter definire degli orari o delle
preferenze in base al carico, cosa che non può essere fatta in modo manuale, con un controllo
umano diretto.
Oltre a questo, quando si amministrano centinaia di utenti, diventa molto impegnativo il compito
di ricordare le scadenze previste per le utenze, rischiando di lasciare attive quelle che non servono
più, o sono inutilizzate da tanto tempo.
Acua 1 è un applicativo che permette di risolvere in parte questi problemi, permettendo di stabilire
in particolare: degli orari, dei limiti di tempo, il numero massimo di accessi contemporanei da
parte dello stesso utente, delle preferenze in base al carico del sistema, l’eliminazione delle utenze
scadute (provvedendo all’avviso preventivo) e l’eliminazione di utenze inattive da molto tempo.
Acua è lo strumento ideale per un fornitore di accesso a Internet, ma anche altri ambienti possono
trovare utile l’utilizzo di questo software.
387.1 Organizzazione generale
Il controllo di Acua si basa su un registro degli utenti sottoposti alla sua amministrazione, un
demone che verifica la presenza di tali utenti nel sistema e di cui controlla l’utilizzo di risorse,
avvalendosi di una serie di programmi e script di contorno.
Perché il controllo abbia un senso, Acua deve avere il modo di impedire l’accesso agli utenti che
accedono al di fuori della loro fascia oraria, o che tentano di utilizzare risorse superiori a quanto
loro concesso. Per questo, la procedura che permette all’utente di accedere deve essere ritoccata,
in modo da inserire una verifica attraverso Acua.
Inoltre, per forzare il rispetto delle regole poste, il demone di Acua deve poter chiudere una
connessione con un utente che ha esaurito le risorse a sua disposizione o che comunque non
ha più diritto di continuare a mantenere la connessione. Ancora, il demone deve prendersi cura
di avvisare dell’imminente scadenza dell’utenza, anche attraverso la posta elettronica, prima di
provvedere alla sua eliminazione definitiva.
Come si può intuire, Acua va a interferire con la gestione tradizionale degli utenti; di sicuro,
almeno quando questo provvede da solo all’eliminazione delle utenze. Infatti, ciò implica la
cancellazione dai file ‘/etc/passwd’, ‘/etc/group’ (con modalità differenti, a seconda che si
usino i gruppi privati o meno) e ‘/etc/shadow’, inoltre implica l’eliminazione della directory
personale dell’utente, assieme alla sua posta elettronica sospesa. Per questo, Acua deve sapere
come gestire questi file, ma soprattutto, dove trovare le directory personali e i file della posta
elettronica.
Acua è così coinvolto nella creazione ed eliminazione degli utenti, che si utilizzano normalmente
due script appositi: ‘acua_adduser’ e ‘acua_deluser’, al posto dei tradizionali ‘adduser’
(‘useradd’) e ‘deluser’ (‘userdel’).2
Il compito di questi è così delicato che non si può evitare di controllarli e modificarli. Solo
se Acua viene distribuito tra i pacchetti ufficiali della propria distribuzione si può sperare che
non si debbano toccare tali script.
1
2
Acua GNU GPL
Per la precisione, si utilizzano i comandi ‘acua addUser’ e ‘acua delUser’, ma questo verrà chiarito in seguito.
4386
Acua
4387
Il demone di Acua, assieme al comportamento dei comandi che si occupano di inserire o modificare le registrazioni degli utenti sottoposti al controllo di Acua, può essere configurato attraverso
un file di configurazione generale.
Il problema di Acua è che raramente fa parte della tipica distribuzione GNU/Linux e questo
significa che lo si trova spesso come pacchetto aggiunto nei contributi. Ciò comporta che non
siano stati presi tutti gli accorgimenti necessari a farlo funzionare subito e che si debbano
modificare necessariamente gli script di creazione e cancellazione degli utenti.
387.1.1 Problemi
Acua non è un sistema di controllo perfetto e nemmeno giunto a un livello di maturazione accettabile per l’uso improvvisato. Dato il tipo di problema che intende cercare di risolvere, si rivolge
a persone che hanno un’ottima esperienza dei sistemi Unix. In tal senso, la documentazione è insufficiente e l’attuazione di determinate strategie implica un’organizzazione iniziale che poi non
può essere sconvolta. Quindi, prima di usare Acua seriamente, occorre essere sicuri di averne
compreso la filosofia e tutte le sue debolezze.
Acua dipende dal funzionamento corretto della registrazione nei file ‘/var/run/utmp’ e ‘/var/
log/wtmp’. Per esempio, se un utente accede senza che ciò venga registrato in questi file, Acua
non può verificare la sua presenza e generalmente si rifiuta di accettarlo. Questo tipo di problema
si verifica effettivamente in alcune distribuzioni GNU/Linux in presenza di accessi attraverso
il PPP, quando vengono utilizzate le librerie PAM; si tratta di un difetto di queste edizioni del
demone ‘pppd’, ma ciò basta a mettere in crisi Acua.
Acua mantiene un proprio elenco degli utenti in cui annota le risorse concesse e utilizzate. Questo
elenco è troppo poco dettagliato, per cui gli utenti sono annotati solo attraverso il numero UID,
non per nome. Inoltre, l’utilizzo di risorse da parte degli utenti è fatto attraverso l’uso di interi: se
per qualche errore di configurazione gli utenti riescono a utilizzare un’unità in più delle risorse
concesse, la detrazione genera un valore negativo, che in un intero produce l’equivalente del
valore massimo gestibile.
387.1.2 Definizione delle risorse
Acua utilizza alcuni concetti per definire le risorse che controlla. Questi concetti, assieme ai
termini utilizzati per identificarli, è bene siano chiariti prima di mettersi a predisporre la configurazione. I più importanti sono riferiti all’utilizzo orario da parte degli utenti e al carico del
sistema. Però è importante non illudersi: alcune cose non funzionano come dovrebbero e per
determinarlo si possono solo fare esperimenti. Precisamente, si distingue tra:
• durata complessiva (time), che rappresenta il tempo massimo a disposizione per l’utilizzo
dell’accesso in un dato intervallo di tempo di riferimento (generalmente si tratta di 24 ore,
una settimana, un mese o un anno);
• durata della sessione (session time), che rappresenta il tempo massimo a disposizione per
una singola connessione;3
• fasce orarie (time class), che servono a definire dei privilegi differenti per i vari utenti in
base al momento in cui questi utilizzano il sistema.
3
A meno di avere verificato effettivamente il funzionamento della gestione del tempo di sessione, è meglio non farne
uso, o al massimo indicare lo stesso valore del tempo totale.
Acua
4388
A questo si affianca poi il concetto del carico del sistema, in base al quale, alcuni utenti possono
essere preferiti ad altri. Il carico del sistema può servire anche per condizionare l’applicazione
delle regole stabilite attraverso le fasce orarie e la durata delle connessioni (opzioni smart...).
387.1.3 Variabili
Nell’elenco degli utenti di Acua vengono gestite una serie di informazioni che all’esterno sono
mostrate come delle variabili. Queste variabili possono essere usate per personalizzare i file dei
messaggi generati da Acua, sia per quanto viene mostrato sullo schermo del terminale, sia per
ciò che viene inviato attraverso la posta elettronica. Per evitare confusioni inutili, è meglio avere
sotto mano uno specchietto di questi nomi, con il loro significato. La tabella 387.1 mostra l’elenco
delle variabili a cui può essere assegnato un valore che esprime una quantità, mentre la tabella
387.2 elenca le variabili booleane, cioè quelle che rappresentano l’attivazione o meno di una
modalità.
Tabella 387.1. Elenco delle variabili principali riferite alla gestione di Acua.
Nome
expire
phNo
priority
maxLogins
maxDeduct
PPPidleBytes
PPPidleMin
tLeft
tLimit
credit
sLeft
sLimit
cLeft
cLimit
bTx
bRx
bTxLimit
bRxLimit
bLimit
bStxLimit
bSrxLimit
bSLimit
Descrizione
Scadenza dell’utenza.
Numero telefonico dell’utente.
Priorità.
Numero massimo di accessi simultanei.
Numero massimo di minuti da dedurre per minuto (<= maxLogins).
Byte transitati al di sotto dei quali la connessione sembra inattiva.
Minuti di tempo durante i quali si calcola il transito minimo.
Tempo complessivo rimasto (minuti).
Tempo complessivo concesso (minuti).
Credito di tempo accumulato (minuti).
Tempo di sessione rimasto (minuti).
Tempo di sessione concesso (minuti).
Tempo di fascia rimasto (minuti).
Tempo di fascia concesso (minuti).
Byte trasmessi.
Byte ricevuti (scaricati).
Limite massimo di byte che possono essere trasmessi.
Limite massimo di byte che possono essere ricevuti.
Limite complessivo al trasferimento in byte.
Limite di sessione dei byte che possono essere trasmessi.
Limite di sessione dei byte che possono essere ricevuti.
Limite di sessione complessivo al trasferimento in byte.
Tabella 387.2. Elenco delle variabili booleane di Acua.
Nome
SMARTTIME
SSMARTTIME
TCSMARTTIME
SMARTBOOT
SSMARTBOOT
TCSMARTBOOT
ISMARTBOOT
WARNBOOT
EXPLAINBOOT
Descrizione
Non deduce il tempo complessivo se il sistema non è sotto carico.
Non deduce il tempo di sessione se il sistema non è sotto carico.
Non deduce il tempo della fascia oraria se il sistema non è sotto carico.
Se il carico è ridotto, non allontana l’utente allo scadere del tempo complessivo.
Se il carico è ridotto, non allontana l’utente allo scadere del tempo di sessione.
Se il carico è ridotto, non allontana l’utente allo scadere del tempo di fascia.
In caso di inattività, l’utente non viene allontanato se il sistema non è sotto carico.
L’utente può essere avvisato della disconnessione imminente.
L’utente può essere avvisato della motivazione della disconnessione.
Acua
4389
387.2 Preparazione
Per utilizzare Acua è necessario mettere in funzione il demone ‘acua_updated’, ma prima di
poterlo fare, bisogna preparare il file di configurazione generale. Come al solito, il posto corretto
per i file di configurazione dovrebbe essere la directory ‘/etc/’, ma se Acua non viene configurato correttamente prima della compilazione, oppure se si utilizza un pacchetto già compilato
che non fa parte della propria distribuzione GNU/Linux ufficiale, è probabile che si trovi altrove
(‘/usr/lib/acua/’ per esempio).4
387.2.1 Azzeramenti
Oltre all’avvio del demone, per utilizzare Acua è necessario azzerare periodicamente i conteggi
dell’utilizzo delle risorse. In precedenza si è accennato alla differenza tra la durata complessiva
dell’utilizzo del sistema da parte di un utente e la durata di un collegamento singolo. La durata
complessiva va riferita a un dato intervallo di tempo, che potrebbe essere l’arco di 24 ore, oppure
una settimana, o un mese, o anche un anno; in ogni caso, qualcosa di ben definito. L’azzeramento
di questi conteggi (che possono riguardare anche altri parametri) deve avvenire con una cadenza
equivalente.
Se si gestiscono le fasce orarie, occorre anche aggiungere un azzeramento giornaliero relativo
a queste. Supponendo che la durata complessiva sia riferita a un anno di tempo, si potrebbero
utilizzare le direttive seguenti nel file di configurazione del sistema Cron.
02 4 * * * root /usr/bin/acua renew -c
03 4 1 1 * root /usr/bin/acua renew
In pratica, seguendo l’esempio, si esegue il comando ‘acua renew -c’ ogni giorno, alle 4:02;
invece, il comando ‘acua renew’ viene eseguito una volta all’anno, precisamente il primo di
gennaio, alle ore 4:03. Naturalmente, la scelta delle ore 4:02 e 4:03 è solo un esempio, con
l’intenzione di indicare un momento in cui l’utilizzo del sistema è minimo.
387.2.2 Configurazione del demone
La configurazione attraverso il file ‘/etc/acua/acua.config’ è piuttosto delicata e importante. La documentazione per questo è composta praticamente solo dai commenti contenuti nell’esempio allegato al pacchetto di Acua. Di seguito verranno mostrati e descritti solo alcune direttive
importanti.
In ogni caso, è bene precisare che i commenti si rappresentano con il simbolo ‘#’, dove ciò che
segue tale simbolo, fino alla fine della riga, viene ignorato; inoltre, come al solito, le righe vuote
e quelle bianche vengono ignorate.
Alcune direttive si riferiscono a caratteristiche delle utenze che vengono prese in considerazione quando si utilizza ‘acua addRec’ (ovvero lo script ‘acua_adduser’). Ciò serve a
facilitare il compito dell’amministratore nell’uniformare gli utenti. Questi dati possono poi
essere modificati attraverso ‘acua modRec’.
Devices dispositivo
[n_quantità ] [dispositivo [n_quantità ] ]...
La direttiva ‘Devices’ serve a definire quali dispositivi, utilizzabili per l’accesso, devono essere controllati dal demone. Ogni dispositivo va indicato senza comprendere la directory che lo
contiene, per cui, ‘/dev/ttyS0’ viene annotato come ‘ttyS0’ e basta.
4
Nel seguito si farà riferimento al file ‘/etc/acua/acua.config’, confidando che sia quella la collocazione
comune.
4390
Acua
Se i dispositivi sono in sequenza, cioè se hanno lo stesso numero primario (major) e il numero
secondario (minor) è in sequenza, si può indicare il primo dispositivo seguito da un numero
che esprime la quantità di questi dispositivi da includere. Per esempio, ‘ttyp0 4’ rappresenta i
dispositivi da ‘/dev/ttyp0’ a ‘/dev/ttyp3’.
PurgeDays n_giorni
Con questa direttiva è possibile automatizzare l’eliminazione delle utenze inutilizzate da tanto
tempo, precisamente dal numero di giorni indicato.
L’eliminazione di questi utenti avviene attraverso uno script di Acua, in questo caso avviato dal
demone. Tuttavia la cosa è così delicata che è importante ricordare di verificare questo script,
prima di avviare il demone stesso.
Se si vuole impedire questo comportamento di Acua, basta indicare il valore zero.
MailHost nome_host
Acua può occuparsi di inviare dei messaggi di preavviso prima della scadenza dell’utenza, avvalendosi per questo della posta elettronica. A volte però, il nodo presso cui sono gestiti gli accessi,
non è quello presso cui gli utenti ricevono la posta elettronica. In tal caso si deve utilizzare questa
direttiva, che serve a specificare il nome di dominio completo del nodo a cui fare riferimento per
l’invio dei messaggi.
WarnBoot n_minuti ...
PPPWarnBoot n_minuti ...
Permette di definire quanti minuti prima della scadenza della connessione avvisare l’utente. Nel
primo caso si tratta di utenti che accedono attraverso un terminale normale (TTY), a cui viene
inviato un messaggio sul terminale, nel secondo si tratta di utenti che accedono attraverso il PPP,
a cui l’avvertimento viene dato per mezzo della posta elettronica.
È molto probabile che ci siano situazioni in cui, sia un tipo di avvertimento, sia l’altro, sono perfettamente inutili. Per esempio, l’utente che accede a un ISP, utilizzando una connessione PPP,
dovrebbe avere sempre attivo un programma per la lettura della posta elettronica dal servente
presso cui questa viene depositata.
WarnExpire n_giorni ...
WarnExpireCC indirizzo_email
Questo è un altro tipo di avvertimento che riguarda la scadenza dell’utenza, dato solo attraverso
la posta elettronica, qualche giorno prima di tale scadenza. I valori numerici indicati nella prima
direttiva sono il numero di giorni prima che si vuole sia emesso l’avvertimento; più numeri
indicano più avvertimenti.
La seconda delle due direttive, serve a inviare una copia di tale messaggio di avvertimento anche
all’amministratore, specificato attraverso il suo indirizzo di posta elettronica.
IdleBoot n_minuti
PPPIdleBoot n_minuti n_byte
Dovrebbe essere conveniente interrompere le connessioni che risultano inattive (idle). Si distingue tra le connessioni da terminale normale, rispetto a quelle che usano il PPP. Nel secondo caso
non è facile determinare bene che la connessione sia inattiva, per cui si stabilisce una quantità
di byte minima che deve transitare attraverso la connessione in un dato intervallo di tempo, per
poter affermare che la connessione sia ancora utilizzata effettivamente.
SmartTime
SessionSmartTime
TimeClassSmartTime
Acua
4391
Le direttive booleane mostrate, se utilizzate, specificano che l’applicazione delle regole riferite al
tempo di utilizzo, al tempo di connessione e ai tempi nelle fasce orarie, è subordinata all’effettiva
necessità di limitare il carico del sistema. Il risultato pratico è che quando il sistema non è carico
eccessivamente, i contatori di utilizzo delle risorse di tempo relative non vengono incrementati.
In effetti, si distinguono due situazioni fondamentali per cui si utilizza Acua: un ISP che offre
un servizio a pagamento; un ente che offre l’accesso alle persone che ne fanno parte. Nel primo
caso, è improbabile che venga offerto un accesso smart, mentre nel secondo dovrebbe essere
logico questo tipo di approccio.
Queste direttive si riferiscono rispettivamente alle variabili ‘SMARTTIME’, ‘SSMARTTIME’ e
‘TCSMARTTIME’.
SmartBoot
SessionSmartBoot
TimeClassSmartBoot
IdleSmartBoot
A differenza delle direttive precedenti, l’utilizzo di queste non interrompe il conteggio dell’utilizzo delle risorse, ma evita la chiusura di una connessione se il carico del sistema non lo
richiede.
In questo caso, si può anche evitare di imporre l’eliminazione di una connessione inattiva (idle),
se il carico del sistema non lo richiede.
Queste direttive si riferiscono rispettivamente alle variabili ‘SMARTBOOT’, ‘SSMARTBOOT’,
‘TCSMARTTIME’ e ‘ISMARTBOOT’.
TimeClass
fascia_oraria ...
La definizione delle fasce orarie è fondamentale, perché nelle indicazioni annotate per ogni utente, si può fare riferimento solo a fasce orarie definite con questa direttiva: la prima, la seconda, la
terza,...
Una fascia oraria è composta dall’indicazione dei giorni della settimana a cui si riferisce e dall’intervallo orario. I giorni della settimana si esprimono attraverso un numero, dove lo zero corrisponde a domenica, mentre gli orari si esprimono in ore e minuti, uniti con un punto. Per
esempio, ‘0-6:0.0-24.0’ indica ogni momento di qualunque giorno della settimana, mentre
‘1-5:8.0-18.0’ rappresenta la fascia oraria che va dalle 8:00 alle 18:00 dei giorni lavorativi
normali (dal lunedì al venerdì).
Generalmente, dovrebbe essere sufficiente l’indicazione delle fasce orarie standard che appaiono
già nel file di configurazione che accompagna Acua.
TimeClass
0-6:0.0-24.0
1-5:8.0-18.0
1-5:19.0-22.0
6-0:0.0-24.0
Infine, è fondamentale escludere alcuni utenti dalle interferenza di Acua. Per la precisione, si
possono escludere alcuni utenti dalle scansioni fatte attraverso il comando ‘acua forEach’,
che verrà descritto in seguito. Si tratta evidentemente degli utenti di sistema, oltre a utenti che
hanno compiti di amministrazione di qualunque tipo.
ForEachExclude utente ...
La direttiva può essere usata anche più volte, in modo da poter suddividere un elenco molto
lungo. È molto importante osservare bene il proprio file ‘/etc/passwd’ per segnalare tutti gli
utenti di sistema e tutti gli amministratori presenti effettivamente.
A titolo di esempio, viene mostrata una configurazione possibile, in cui, come si noterà, non si
concedono privilegi di tipo smart.
Acua
4392
# Controlla l’accesso attraverso gli pseudoterminali e i terminali seriali.
Devices ttyp0 64 ttyS0 64
# Elimina le utenze inutilizzate da 6 mesi (180 giorni).
PurgeDays 180
# La deduzione minima per collegamento è di un minuto.
MinDeduct 1
# Il sistema viene considerato carico (impegnato) quando non ci sono
# più linee dial-up (di accesso telefonico) libere.
BusyThreshold 0
# Mappa le priorità di CPU secondo la classificazione di Acua.
CPUpriority 19 -20
# Il nome del nodo presso cui risiedono le caselle postali degli
# utenti a cui inviare i messaggi di avvertimento.
#MailHost posta.mio.dominio
# Avvisa della scadenza attraverso la posta elettronica: due settimane
# prima, una settimana prima e un giorno prima.
WarnExpire 14 7 1
# Avvisa anche l’amministratore.
#WarnExpireCC [email protected]
# Vengono concessi al massimo 15 minuti di inattività.
IdleBoot 15
# Attraverso la connessione PPP, vengono concessi un massimo di 15 minuti
# di inattività; per determinarlo si stabilisce che si arriva a questo
# se sono stati trasferiti meno di 15360 byte (1 Kibyte al minuto).
PPPIdleBoot 15 15360
#
#
#
#
#
#
#
#
#
Non viene concesso alcun privilegio «smart».
SmartTime
SessionSmartTime
TimeClassSmartTime
SmartBoot
SessionSmartBoot
TimeClassSmartBoot
IdleSmartBoot
# Si fissano le fasce orarie standard.
# fascia 0: 24 ore da lunedì a domenica
# fascia 1: dalle 8 alle 18, da lunedì a venerdì
# fascia 2: dalle 19 alle 22, da lunedì a venerdì
# fascia 3: 24 ore da sabato a domenica
TimeClass 0-6:0.0-24.0 1-5:8.0-18.0 1-5:19.0-22.0
(orario di ufficio)
(prima serata)
(fine settimana)
6-0:0.0-24.0
# Esclude gli utenti di sistema e di amministrazione dalle scansioni
# fatte attraverso «acua forEach».
ForEachExclude root bin daemon adm lp sync shutdown halt mail news uucp
ForEachExclude operator games gopher ftp nobody postgres exim
ForEachExclude daniele
Acua
4393
387.2.3 Creazione ed eliminazione degli utenti
La creazione e l’eliminazione degli utenti gestiti da Acua, deve essere predisposta attraverso
due script che vanno modificati opportunamente. Anche questa fase è da considerare parte della
configurazione. Eventualmente, gli utenti potrebbero essere inseriti nel controllo di Acua anche
in modo differente, ma è importante che lo script di cancellazione, ‘acua_deluser’, funzioni
correttamente, dal momento che può essere utilizzato dal demone per eliminare le utenze scadute
e quelle inutilizzate da molto tempo.
387.2.3.1 Creazione con acua_adduser
acua_adduser utente
[numero_telefonico ]
Si tratta di uno script preparato per una shell di Bourne e quindi compatibile anche con la shell
Bash.
#! /bin/sh
Nella prima parte vengono definite alcune variabili, attraverso cui diventa più facile impostare i
parametri essenziali per l’utilizzo di ‘acua addRec’, che verrà descritto più avanti.
DEFAULT_EXPIRY=0
DEFAULT_TLIMIT=120
DEFAULT_SLIMIT=120
DEFAULT_PRIORITY=4
La variabile ‘DEFAULT_EXPIRY’ permette di indicare quanto tempo è valida la registrazione
dell’utenza (questo viene espresso generalmente in giorni). Lo zero rappresenta l’assenza di una
scadenza.
Le variabili ‘DEFAULT_TLIMIT’ e ‘DEFAULT_SLIMIT’ servono a indicare rispettivamente il tempo complessivo a disposizione e il tempo massimo di sessione. Il valore si esprime in minuti e nell’esempio i dati coincidono, a indicare che l’utente ha a disposizione due ore che può impiegare
anche completamente in una sola sessione.
Più avanti, dopo la definizione di alcune funzioni, inizia l’acquisizione degli argomenti forniti.
Se non si indica il numero telefonico, viene utilizzato il valore -1. Ciò che si ottiene sono le
variabili ‘LOGIN’ e ‘PH_NO’, contenenti rispettivamente il nominativo-utente da creare e il suo
numero di telefono.
Infine viene creato l’utente, attraverso ‘adduser’ (se si usano le password shadow si tratterà di
un collegamento a ‘useradd’) e poi viene registrato all’interno di Acua, utilizzando i parametri
indicati con le variabili già viste.
# Crea l’utente
adduser $LOGIN || err
# Registra l’utente in Acua
acua addRec $LOGIN $DEFAULT_EXPIRY $DEFAULT_TLIMIT $DEFAULT_SLIMIT \
$DEFAULT_PRIORITY "$PH_NO" || err
# Impone l’indicazione della password
passwd $LOGIN || err
# Cambia la shell
#chsh -s /bin/zsh $LOGIN || err
# Accumula le informazioni finger
chfn $LOGIN
exit 0
Questa parte richiede attenzione. Per prima cosa occorre notare la modifica della shell dell’utente.
A parte la scelta proposta dall’autore di Acua, che vorrebbe fosse utilizzato ‘zsh’ da tutti, se si
tratta della creazione di utenze per l’accesso attraverso la linea commutata, è molto probabile che
4394
Acua
non possa trattarsi di una shell comune, dovendo essere piuttosto uno script di connessione per
l’attivazione del PPP.
Inoltre, come si vedrà in seguito a proposito di ‘acua addRec’, non appare definito l’utilizzo
delle fasce orarie, cosa che si colloca dopo l’indicazione del numero telefonico.
Una volta definite le politiche cui sottoporre gli utenti, è possibile predisporre degli script
diversi, in funzione delle diverse categorie che si desiderano gestire.
387.2.3.2 Eliminazione con acua_deluser
acua_deluser utente
Questo script è più importante di quello di creazione, soprattutto perché potrebbe essere avviato
dal demone ‘acua_updated’ (attraverso il comando ‘acua delUser’). Inoltre, è anche più
delicato, perché va direttamente a modificare i file ‘/etc/passwd’, ‘/etc/group’ e ‘/etc/
shadow’.
A proposito dell’intervento nel file ‘/etc/group’, occorre verificare se gli utenti fanno parte
di un gruppo comune, o se si applica la politica dei gruppi privati, in cui ogni utente ha un
proprio gruppo. Infatti, solo nel secondo caso ha senso eliminare il gruppo dell’utente che viene
cancellato.
acua kickUser $LOGIN
acua delRec $LOGIN
Per prima cosa, come si vede, l’utente viene disconnesso, mentre subito dopo viene rimosso dal
registro di Acua.
Successivamente si passa all’eliminazione vera e propria dell’utente, come si vede sotto. Il problema sta nel verificare che tutto corrisponda alla realtà del proprio sistema. L’esempio mostrato
sotto è un po’ diverso rispetto al contenuto standard di questo script; in particolare, si fa riferimento ai gruppi privati, per cui viene eliminato anche il gruppo che abbia lo stesso nome
dell’utente.
# Si modifica opportunamente la maschera umask per motivi di sicurezza.
umask 077
# Si fa una copia di sicurezza del file /etc/passwd
cp -f /etc/passwd /etc/passwd.orig
# Toglie il record dell’utente dal file /etc/passwd
grep -v \^$LOGIN: /etc/passwd > /etc/passwd.$$
mv /etc/passwd.$$ /etc/passwd
# Sistema la proprietà e i permessi
chown root.root /etc/passwd ; chmod 644 /etc/passwd
# Se esiste il file /etc/shadow, cerca di intervenire anche lì.
if [ -f /etc/shadow ]; then
# Si fa una copia di sicurezza del file /etc/shadow
cp -f /etc/shadow /etc/shadow.orig
# Toglie il record dell’utente dal file /etc/passwd
grep -v \^$LOGIN: /etc/shadow > /etc/shadow.$$
mv /etc/shadow.$$ /etc/shadow
chown root.root /etc/shadow ; chmod 400 /etc/shadow
Acua
4395
fi
# Si fa una copia di sicurezza del file /etc/group
cp -f /etc/group /etc/group.orig
# Cerca di eliminare le tracce dell’utente dal file /etc/group:
# sia le aggregazioni nei gruppi, sia il suo gruppo privato.
gawk -v login=$LOGIN ’{
if ($0 ~ ".*" login ".*") {
if ($0 !~ "^" login ":.*") {
gsub("," login, "");
gsub(":" login, ":");
print;
}
} else print;
}’ /etc/group > /etc/group.$$
mv /etc/group.$$ /etc/group
chown root.root /etc/group ; chmod 644 /etc/group
Infine, si eliminano la directory personale dell’utente e la casella di posta elettronica. Anche
questi due elementi possono essere delicati per il proprio sistema; infatti, non è detto che le
directory personali degli utenti si trovino necessariamente nella directory ‘/home/’, così come
la posizione della casella postale non è ovvia.
# Elimina la directory home e il file della casella postale
rm -rf /home/$LOGIN
rm -f /var/mail/$LOGIN
387.2.4 Filtro di ingresso
Acua deve avere il modo di impedire l’accesso agli utenti che hanno esaurito le loro risorse,
inoltre deve essere «avvisato» quando l’utente accede. Per questo si interviene normalmente
attraverso la shell, oppure attraverso lo script che ne prende il posto.
Per comprendere il problema, si immagini il controllo di un accesso normale attraverso un terminale, dove l’utente corrispondente ha una shell Bash. In tal caso, si può modificare il file ‘/etc/
profile’ di questa shell per inserire il comando:
/usr/sbin/acua_login || logout
In pratica, sarebbe come se fosse stato scritto quanto segue:
if ! /usr/sbin/acua_login
then
logout
fi
387.3 Gestione
Tutti i comandi di Acua che possono servire per la sua gestione sono filtrati dall’eseguibile
‘acua’, che a seconda del primo argomento si comporta in modi molto differenti. Spesso, l’eseguibile ‘acua’ deve avviare a sua volta altri eseguibili, o anche degli script; quando si tratta di
operazioni che non possono essere accessibili agli utenti comuni, i permessi che contano sono
dati proprio da questi programmi avviati successivamente da ‘acua’.
In queste sezioni verranno mostrati solo alcuni dei comandi di Acua, a volte anche in modo
approssimativo. Per gli altri si può consultare la documentazione originale, che su questo punto
è sufficientemente dettagliata.
Acua
4396
387.3.1 # acua addUser
acua addUser utente
‘acua addUser’ permette di creare un nuovo utente, registrandolo anche sotto Acua. Questo
comando, tuttavia, richiama semplicemente lo script ‘acua_adduser’, che come già spiegato,
deve essere modificato opportunamente.
Non c’è alcuna necessità di utilizzare il comando ‘acua addUser’, in quanto lo script da solo
è più che sufficiente. Anzi, potrebbero essere preparati più script per diversi tipi di utenti che si
vogliono poter inserire nel sistema.
È bene ricordare che dipende dallo script se poi è necessario intervenire ulteriormente oppure
no. Per esempio, potrebbe essere necessario definire la parola d’ordine dell’utente e forse
anche la shell, tenendo conto del tipo di accesso che viene consentito all’utente.
387.3.2 # acua delUser
acua delUser utente
‘acua delUser’ permette di eliminare un utente registrato anche sotto Acua. Questo comando,
tuttavia, richiama semplicemente lo script ‘acua_deluser’, che come già spiegato, deve essere
modificato opportunamente.
Non c’è alcuna necessità di utilizzare il comando ‘acua delUser’, in quanto lo script da solo è
più che sufficiente.
387.3.3 # acua addRec
acua addRec utente scadenza tempo_massimo ←,→ sessione_massima
priorità telefono
limite_di_fascia ...
[
[
[
[
]]]]
‘acua addRec’ permette di aggiungere un utente nel registro di Acua. Viene chiamato all’interno dello script ‘acua_adduser’ e può essere usato direttamente per aggiungere il controllo di
un utente che è già stato inserito nel sistema (ma non ancora sotto il controllo di Acua).
Sono obbligatori solo i primi tre argomenti (dopo ‘addRec’), mentre a partire dal quarto, sono
obbligatori solo gli argomenti precedenti a quello che si vuole inserire (per esempio, non si può
saltare il numero telefonico e inserire i limiti di fascia oraria).
1. utente
Il nome utilizzato dall’utente per identificarsi all’atto dell’accesso.
2. scadenza
Rappresenta la scadenza dell’utenza secondo Acua (indipendente da quanto indicato nel file
‘/etc/shadow’). La scadenza può essere definita attraverso un numero, che rappresenta
normalmente una quantità di giorni, oppure in modo esplicito, nella forma ‘aa/mm /gg’
(anno/mese/giorno), dove l’anno può utilizzare solo due cifre numeriche.
Se si indica un numero, questo può anche essere seguito da una lettera, per esprimere: ‘d’,
giorni (predefinito); ‘m’, mesi; ‘y’, anni. La scadenza è riferita sempre alla fine dell’unità
indicata, ma per difetto; per esempio, nel caso si indichino mesi, la scadenza si riferisce
Acua
4397
alla fine del mese finale, includendo il mese in corso, anche se questo è già a metà, oppure
oltre.
Per inibire la scadenza, basta utilizzare il valore zero.
Questo valore viene annotato nella variabile ‘expire’.
3. tempo_massimo
Il tempo massimo concesso all’utente. Tale durata si esprime in minuti.
Se si indica il valore -1, si intende una durata indefinitamente grande.
Questo valore viene annotato nella variabile ‘tLimit’.
4. sessione_massima
Stabilisce la durata massima della sessione. Anche questo valore si esprime in minuti. Se
non viene specificato, si assume corrisponda al tempo massimo.
Questo valore viene annotato nella variabile ‘sLimit’.
5. priorità
Fissa la priorità di questo utente, che si esprime con un valore che va da zero a sette, dove
lo zero esprime il trattamento peggiore.
Questo valore può tradursi in una diversa priorità di CPU, secondo quanto definito nel file
di configurazione, con la direttiva ‘CPUpriority’. Se è così, dovrebbe essere sconveniente
tentare di utilizzare priorità di Acua che poi si traducono in priorità di CPU negative.
In generale, il valore predefinito per questa priorità di Acua è quattro.
Questo valore viene annotato nella variabile ‘priority’.
6. numero_telefonico
Questo argomento è dedicato al numero telefonico dell’utente. A quanto pare, Acua accetta
solo un formato particolare che non è indicato nella documentazione; inoltre, è probabile
che tale informazione possa essere ottenuta anche da utenti comuni che hanno accesso al
sistema, mentre si presume che si tratti di una notizia riservata.
Si può trascurare questo argomento, indicando eventualmente il valore zero, o -1.
Questo valore viene annotato nella variabile ‘phNo’.
7. limite_di_fascia ...
Gli ultimi argomenti sono in quantità variabile e dipendono delle fasce orarie definite nel
file di configurazione generale. Se si lasciano le fasce orarie standard, se ne hanno a disposizione quattro e per ognuna di queste può apparire un argomento che definisce il limite
relativo.
Per ogni fascia oraria può essere indicato un valore che corrisponde al limite di tempo
consentito per gli accessi, espresso in minuti. Evidentemente, tale limite si sostituisce a
quello generico definito con il terzo argomento di questo comando. In alternativa si possono
indicare i valori seguenti:
• 0 viene usato per impedire l’accesso in quella fascia oraria;
• -1 rappresenta l’utilizzo del limite di tempo stabilito in modo generico (il terzo
argomento del comando) ed è il dato predefinito;
• -2 fa in modo che in quella fascia oraria non venga calcolato il tempo di sessione,
mentre il tempo complessivo continua a esserlo;
• -3 fa in modo che in quella fascia oraria non venga calcolato né il tempo di sessione
né il tempo complessivo.
Acua
4398
Molte informazioni che riguardano l’utente non possono essere indicate attraverso
‘acua addRec’. Queste possono essere specificate in modo predefinito nel file di configurazione
(‘/etc/acua/acua.config’) e poi possono essere modificate attraverso ‘acua modRec’.
Esempi
# acua addRec pippo 365 120 120 4 0 -1 -1 -1 -1
Registra l’utente ‘pippo’ all’interno della gestione di Acua, specificando una scadenza
dell’utenza dopo 365 giorni, con un tempo massimo di accesso (probabilmente giornaliero)
di due ore, un tempo massimo di sessione di due ore, un livello di priorità pari a quattro,
senza telefono e senza limitazioni riferite alle fasce orarie (gli ultimi quattro -1).
# acua addRec pippo 365 120
Esattamente come nell’esempio precedente, perché gli argomenti mancanti corrispondono
ai valori predefiniti.
# acua addRec pippo 365 120 120 4 0 -1 0 -1 -1
Come nell’esempio precedente, con la differenza che l’utente ‘pippo’ non può accedere
nella seconda fascia oraria (il valore zero).
# acua addRec pippo 365 120 120 4 0 -1 60 -1 -1
Come nell’esempio precedente, con la differenza che l’utente può utilizzare solo un’ora
nella seconda fascia oraria.
# acua addRec pippo 10/01/01 120 120 4 0 -1 -1 -1 -1
Registra l’utente ‘pippo’ all’interno della gestione di Acua, specificando la scadenza
dell’utenza nel primo gennaio del 2010. Gli altri dati sono uguali a quelli del primo
esempio.
387.3.4 # acua modRec
acua modRec
[-s]
utente altri_argomenti
Il comando ‘acua modRec’ è molto importante e può articolarsi in forme molto differenti. Il suo
scopo è quello di modificare la configurazione di un utente, soprattutto su particolari che non
possono essere definiti attraverso ‘acua addRec’.
In questa sezione verranno mostrate solo alcune delle possibilità di questo comando. Per un
dettaglio maggiore si può provare a consultare la documentazione originale.
L’azione di ‘acua modRec’ è limitata a ciò che si specifica, senza alcuna verifica della congruenza di ciò che si fa. Per fare un esempio, se si decide di aumentare il tempo totale concesso
a un utente, è anche probabile che gli si voglia aumentare il tempo totale rimasto a disposizione, altrimenti il risultato pratico potrebbe non corrispondere a quanto inteso. A questo
proposito, è bene usare sempre ‘acua viewRec’ dopo ogni modifica, per verificare che la
situazione dell’utente corrisponda a quanto voluto.
Caratteristiche generali
acua modRec utente scadenza tempo_massimo
[sessione_massima [priorità [limite_di_fascia ...]]]
In questo modo è possibile definire gli elementi principali riferiti alla registrazione di un
certo utente. Come si può osservare, è quasi uguale alla sintassi di ‘acua addRec’, con la
differenza che non è prevista l’indicazione del telefono.
Acua
4399
Purtroppo, questa forma di utilizzo di ‘acua modRec’ non funziona sempre come dovrebbe. In particolare, potrebbero essere cancellate le fasce orarie e potrebbe anche essere impossibile modificarle successivamente. Se questo dovesse succedere, probabilmente
l’unica possibilità di rimediare è l’uso di ‘acua delRec’ seguito da ‘acua addRec’,
utilizzando i valori corretti; successivamente, come si può leggere sotto, attraverso
‘acua modRec’ usato nella sua sintassi alternativa, si possono ripristinare i valori
corretti per quanto riguarda le risorse già utilizzate.
Modalità
acua modRec utente
{+|-}modalità
Le informazioni legate agli utenti prevedono la presenza di molte variabili booleane, corrispondenti a modalità che possono essere attivate o disattivate. Come si può intuire, il
simbolo ‘+’ davanti a un nome attiva la modalità corrispondente, mentre il segno ‘-’ la
disattiva.
È possibile definire una configurazione predefinita per queste modalità, attraverso il file di
configurazione generale, anche se i nomi utilizzati non sono gli stessi. Di seguito appare
l’elenco di alcuni di questi nomi di modalità, per ciò che riguarda ‘acua modRec’.
• ‘SMARTTIME’
Equivale alla direttiva ‘SmartTime’; permette di non incrementare il conteggio della
durata globale di utilizzo del servizio se il carico del sistema non risulta eccessivo.
• ‘SSMARTTIME’
Equivale alla direttiva ‘SessionSmartTime’; permette di non incrementare il
conteggio della durata della sessione se il carico del sistema non risulta eccessivo.
• ‘TCSMARTTIME’
Equivale alla direttiva ‘TimeClassSmartTime’; permette di non incrementare il conteggio della durata di utilizzo riferito alla fascia oraria corrispondente se il carico del
sistema non risulta eccessivo.
• ‘SMARTBOOT’
Equivale alla direttiva ‘SmartBoot’; consente all’utente di restare nel sistema quando
il tempo complessivo è esaurito se il carico del sistema non risulta eccessivo.
• ‘SSMARTBOOT’
Equivale alla direttiva ‘SessionSmartBoot’; consente all’utente di restare nel sistema quando il tempo massimo per una singola sessione è esaurito se il carico del
• ‘TCSMARTBOOT’
Equivale alla direttiva ‘TimeClassSmartBoot’; consente all’utente di restare nel sistema quando il tempo complessivo riferito alla fascia oraria è esaurito se il carico del
• ‘ISMARTBOOT’
Equivale alla direttiva ‘IdleSmartBoot’; consente all’utente di restare nel sistema
quando il tempo massimo di inattività è stato superato se il carico del sistema non
risulta eccessivo.
• ‘WARNBOOT’
Equivale alla direttiva ‘WarnBoot’; fa sì che l’utente sia avvisato dell’imminente
disconnessione.
Acua
4400
• ‘EXPLAINBOOT’
Equivale alla direttiva ‘ExplainBoot’; fa sì che l’utente venga informato del motivo
per cui è stato disconnesso. Questa informazione viene fornita attraverso un messaggio
di posta elettronica e, se possibile, anche attraverso il terminale, quando il tipo di
accesso lo consente.
Assegnamento di valori a opzioni
acua modRec utente variabile
{=|+=|-=}
valore
Oltre alle modalità (booleane), sono annotate una serie di informazioni che possono essere modificate con un assegnamento (‘=’), con un incremento (‘+=’) o con un decremento
(‘-=’).
La maggior parte di queste indicazioni sono definite in modo preliminare nel file di configurazione generale, mentre altre riguardano la contabilizzazione degli accessi e vengono
gestite dinamicamente in base all’utilizzo da parte dell’utente. Di seguito appare l’elenco
di alcune di queste variabili.
• ‘priority’
Definisce il livello di priorità dell’utente.
• ‘maxLogins’
Il numero massimo di accessi simultanei (di solito ne viene consentito uno solo).
• ‘PPPidleByte’, ‘PPPidleMin’
La connessione PPP viene considerata inattiva se sono stati trasmessi meno di
‘PPPidleByte’ byte in ‘PPPidleMin’ minuti.
Nel file di configurazione può essere usata la direttiva ‘PPPIdleBoot’ per definire
entrambi questi valori.
• ‘tLimit’, ‘tLeft’
L’accesso a queste due variabili permette di modificare rispettivamente il tempo
massimo a disposizione e il tempo rimasto, alterando così quanto contabilizzato da
Acua.
• ‘sLimit’, ‘sLeft’
L’accesso a queste due variabili permette di modificare rispettivamente il tempo massimo di sessione e il tempo di sessione rimanente, alterando così quanto contabilizzato
da Acua.
• ‘cLimit’, ‘cLeft’
L’accesso a queste due variabili permette di modificare rispettivamente il tempo massimo di fascia oraria e il tempo di fascia rimanente, alterando così quanto contabilizzato
da Acua.
• ‘bTx’, ‘bRx’
Definiscono la quantità di byte trasmessi e ricevuti (upload, download). Intervenendo
su questi valori si altera la contabilizzazione di Acua.
• ‘bTxLimit’, ‘bRxLimit’
Definiscono il limite massimo di byte trasmessi e ricevuti (upload, download).
• ‘bLimit’
Definisce il limite massimo di byte che possono transitare (la somma di quelli
trasmessi e di quelli ricevuti).
• ‘bStxLimit’, ‘bStxLimit’
Definiscono il limite massimo di byte trasmessi e ricevuti per sessione (upload,
download).
Acua
4401
• ‘bSLimit’
Definisce il limite massimo di byte che possono transitare per sessione (la somma di
quelli trasmessi e di quelli ricevuti).
Esempi
# acua modRec pippo 10/01/01 12000 12000 4 -1 60 -1 -1
Modifica l’impostazione dell’utente ‘pippo’, fissando la scadenza al 1/1/2010, definendo
il tempo massimo complessivo e anche quello di sessione in 200 ore (12000 minuti), indicando il livello di priorità (4) e le fasce orarie (nella seconda viene concesso di accedere
per un’ora).
Purtroppo, è probabile che questo comando non funzioni, pur essendo corretto sintatticamente. Se ‘acua modRec’ non risponde correttamente a questa forma della sintassi,
non ci sono altri rimedi che farne a meno.
# acua modRec pippo +EXPLAINBOOT
Attiva la modalità ‘EXPLAINBOOT’ per l’utente ‘pippo’.
# acua modRec pippo -WARNBOOT
Disattiva la modalità ‘WARNBOOT’ per l’utente ‘pippo’.
# acua modRec pippo tLimit = 24000
Modifica il tempo complessivo concesso, portandolo a 400 ore (24000 minuti).
# acua modRec pippo tLeft = 24000
Modifica il tempo complessivo rimanente, portandolo a 400 ore (24000 minuti).
387.3.5 # acua subscribe
acua subscribe utente scadenza tempo_massimo
[sessione_massima [priorità [limite_di_fascia ...]]]
Per motivi di praticità, è possibile definire una registrazione aggiuntiva che si sovrappone alla
situazione esistente dell’utente a cui viene applicata. Quando l’utente è «iscritto», tutte le modifiche che possono essere fatte attraverso ‘acua modRec’ si riferiscono a questo strato aggiuntivo, che ha effetto fino alla scadenza stabilita (l’argomento che segue l’indicazione dell’utente),
oppure fino a quando si utilizza ‘acua unsubscribe’.
È importante chiarire che tutte le modifiche apportate quando è attiva l’iscrizione, vengono
perdute nel momento in cui questa viene rimossa, riportando tutto allo stato precedente.
Esempi
# acua subscribe pippo 05/01/01 24000 24000 4 -1 120 -1 -1
Modifica temporaneamente l’impostazione dell’utente ‘pippo’, fissando la scadenza di
queste modifiche al 1/1/2005, definendo il tempo massimo complessivo e anche quello
di sessione in 400 ore (24000 minuti), indicando il livello di priorità (4) e le fasce orarie
(nella seconda viene concesso di accedere per due ore).
Come nel caso di ‘acua modRec’, è probabile che questo comando, pur essendo corretto
sintatticamente, non funzioni, andando a modificare in modo errato i tempi assegnati alle
fasce orarie
Acua
4402
387.3.6 # acua unsubscribe
acua unsubscribe utente
Elimina lo strato aggiunto attraverso l’iscrizione di un utente, riportando il suo stato a quello
esistente prima di quel momento.
387.3.7 # acua delRec
acua delRec utente
Toglie un utente dal controllo di Acua, cancellando la registrazione corrispondente. Di
solito, viene utilizzato direttamente dallo script ‘acua_deluser’, ovvero dal comando
‘acua delUser’.
387.3.8 # acua viewRec
acua viewRec
[utente]
‘acua viewRec’ permette di conoscere lo stato dell’utente specificato, o di quello che ha avviato
il comando. Per farlo si avvale di ‘acua_viewRec’. Il problema di questo comando è che può
essere utilizzato da qualunque utente, cosa che potrebbe essere interpretata come una violazione
della riservatezza personale.
È importante decidere se rendere pubbliche tali informazioni o meno. Se si vuole evitarlo, basta
che il programma ‘acua_viewRec’ abbia i permessi di esecuzione esclusivamente per l’utente
‘root’.
Segue un esempio riferito all’utente ‘tizio’, appena creato, al quale viene concesso un tempo
complessivo e un tempo di sessione di 200 ore (12000 minuti), inoltre, nella seconda fascia oraria
gli viene concesso di accedere solo per un’ora. Per quanto riguarda le altre risorse non sono stati
stabiliti limiti particolari; la scadenza dell’utenza è il giorno 1/1/2010.
login:
util:
online:
phone:
priority:
flags:
uflags:
maxLogins:
idleLimit:
time:
class:
data:
data TX:
data RX:
creation:
expiry:
lock:
subscr:
last log:
last on:
tizio
0.00%
NO
N/A
4
[TCSMARTBOOT WARNBOOT EXPLAINBOOT]
[]
1 [maxDeduct = 1]
[TTY = 00:15] [PPP = 15360 bytes in 00:15]
total: [200:00 + 00:00 / 200:00] session: [200:00 / 200:00]
[-00:01 / +INF] [01:00 / 01:00] [-00:01 / +INF] [-00:01 / +INF]
total: [0.00 KB / +INF] session: [0.00 KB / +INF]
Sat Jan 2 21:42:23 1999
DELETE in 4016.10 days [Fri Jan 1 00:00:00 2010]
N/A
N/A
Sat Jan 2 21:42:23 1999
-0.00 days [Sat Jan 2 21:42:23 1999]
Acua
4403
387.3.9 # acua forEach
acua forEach
[opzioni]
comando
‘acua forEach’ permette di scandire l’elenco degli utenti, eseguendo per ognuno di loro il
comando posto alla fine degli argomenti. ‘acua forEach’ esclude dalla scansione gli utenti
indicati espressamente nel file di configurazione generale con la direttiva ‘ForEachExclude’.
All’interno del comando da eseguire attraverso ‘acua forEach’ è possibile passare il nome
dell’utente per il quale viene eseguito, inserendo il simbolo ‘{}’, come si fa con ‘find’ per
passare il nome del file trovato. Come al solito, può darsi che le parentesi graffe debbano essere
protette dall’interpretazione della shell, come succede se si usa la shell Bash.
Alcune opzioni
-u
Specifica che deve essere fatta la scansione dei soli utenti per i quali esista effettivamente
una registrazione all’interno di Acua.
Esempi
# acua forEach -u acua modRec \{\} expire = 1y
Scandisce ogni utente registrato con Acua e gli assegna la scadenza dell’utenza alla fine
dell’anno in corso.
# acua forEach acua addRec \{\} 1y 120
Scandisce tutti gli utenti, esclusi quelli indicati nella configurazione generale con la direttiva ‘ForEachExclude’, allo scopo di aggiungerli alla gestione di Acua, assegnando la
scadenza dell’utenza alla fine dell’anno in corso, concedendo un tempo massimo di due ore
(120 minuti).
387.4 Funzionamento
Il funzionamento quotidiano di Acua è attuato dal demone ‘acua_updated’, il quale si avvale di
altri programmi e script, e da ‘acua_login’ che annota immediatamente l’ingresso di un utente,
o gli impedisce di accedere.
387.4.1 # acua_updated
acua_updated
[opzioni]
‘acua_updated’ è il demone che controlla l’utilizzo del sistema, esegue le operazioni di
contabilizzazione, interrompe le connessioni quando necessario ed eventualmente elimina gli
utenti.
Per compiere queste funzioni si avvale eventualmente dei comandi ‘acua sync’, ‘acua purge’
e ‘acua expire’.
Generalmente, ‘acua_updated’ viene avviato senza opzioni, o al massimo con l’opzione ‘-a’,
allo scopo di evitare che vengano compiute operazioni di manutenzione che implicano l’utilizzo
di ‘acua sync’, ‘acua purge’ e ‘acua expire’, lasciando all’amministratore il compito di
provvedere a queste cose.
Acua
4404
387.4.2 # acua sync
acua sync
‘acua sync’ serve a sincronizzare le informazioni di Acua con il file ‘/etc/passwd’, allo
scopo di eliminare registrazioni riferite a utenti che non esistono più. In generale, questo comando
dovrebbe essere eseguito periodicamente da ‘acua_updated’.
387.4.3 # acua purge
acua purge giorni
‘acua purge’ elimina le utenze che risultano inutilizzate dal numero di giorni indicato come
argomento. Viene usato generalmente in modo automatico da ‘acua_updated’, che a sua volta
utilizza quanto definito nella configurazione.
387.4.4 # acua expire
acua expire
‘acua expire’ elimina le utenze scadute, oppure le iscrizioni scadute. In pratica, se un utente
ha un’iscrizione scaduta, viene eseguito ‘acua unsubscribe’, se invece è scaduta proprio la
registrazione, allora l’utente viene eliminato attraverso ‘acua delUser’ (cosa che poi avvia il
solito script ‘acua_deluser’).
‘acua expire’ viene eseguito normalmente attraverso ‘acua_updated’, in modo da rendere
automatica l’operazione.
387.4.5 $ acua_login
acua_login
[utente]
acua_login < terminale
‘acua_login’ deve essere utilizzato per autorizzare l’accesso degli utenti controllati da Acua. Se
l’utente non è autorizzato, ‘acua_login’ restituisce un valore diverso da zero (Falso) e questo
viene sfruttato per realizzare uno script per controllare l’accesso, come già mostrato all’inizio del
capitolo.
L’avvio di ‘acua_login’ è necessario anche per inizializzare alcuni valori riferiti all’utente nel
sistema di Acua e quindi non se ne può fare a meno.
‘acua_login’ può essere avviato senza l’indicazione esplicita dell’utente, se il processo appartiene all’utente stesso; in alternativa, si può fornire a ‘acua_login’ il dispositivo del terminale
da cui accede l’utente, sempre allo scopo di riconoscerlo.
‘acua_login’ dipende dalle informazioni contenute nei file ‘/var/run/utmp’ e ‘/var/
log/wtmp’; se per qualche motivo questi non vengono aggiornati correttamente,
‘acua_login’ non riesce a verificare l’accesso da parte dell’utente e restituisce il valore
Falso.
Esempi
#!/bin/sh
Acua
4405
/usr/bin/mesg n
/bin/stty -tostop
# Verifica che l’utente possa accedere.
if /usr/sbin/acua_login
then
# L’utente viene accolto.
echo Benvenuto $LOGNAME
else
# L’utente viene estromesso.
logout
fi
# Attiva la connessione PPP.
echo "Viene attivata la connessione PPP."
exec /usr/sbin/pppd crtscts modem noauth refuse-chap refuse-pap \
debug proxyarp idle 600
Lo script che si vede è un esempio di shell per un utente che sfrutta la connessione per
attivare un collegamento PPP, alla fine della procedura di autenticazione tradizionale.
#! /bin/sh
# /etc/ppp/ip-up
#...
if ! /usr/sbin/acua_login < $DEVICE
then
kill -15 "$PPID"
exit
fi
Quello che si vede sopra è una parte di un ipotetico script ‘/etc/ppp/ip-up’. Questo
viene avviato da ‘pppd’ dopo la connessione e serve nel caso l’autenticazione avvenga attraverso il protocollo PPP stesso. In particolare, la variabile di ambiente ‘DEVICE’ contiene
il percorso assoluto del dispositivo di terminale attraverso il quale l’utente accede, mentre
la variabile ‘PPID’ contiene il numero del processo corrispondente a ‘pppd’.
387.4.6 $ acua renew
acua renew
[opzioni]
‘acua renew’ viene usato per azzerare i conteggi riferiti a tutti gli utenti. Se non vengono
utilizzate le opzioni, si azzera tutto ciò che può esserlo.
Alcune opzioni
-c
Azzera i conteggi riferiti alle fasce orarie. Di solito, il tempo a disposizione riferito a una
fascia oraria determinata, viene inteso come utilizzabile nell’arco delle 24 ore, per cui è
opportuno eseguire il comando ‘acua renew -c’ ogni giorno, attraverso il sistema Cron.
-d
Azzera i conteggi riferiti ai trasferimenti di dati.
-t
Azzera i conteggi riferiti al tempo complessivo.
Acua
4406
387.5 Altra configurazione
È possibile personalizzare meglio il funzionamento di Acua intervenendo su altri file, oltre a quello di configurazione generale. All’interno della directory ‘/etc/acua/’ (ma potrebbe trattarsi
invece di ‘/usr/lib/acua/’) dovrebbero trovarsi altri file di configurazione, assieme ai messaggi che possono essere generati da Acua (per avvisare l’utente dell’imminente disconnessione,
o di altre cose).
Se si vuole utilizzare Acua professionalmente, diventa indispensabile tradurre tali file.
A titolo di esempio, viene mostrato il contenuto del file ‘/usr/lib/acua_viewRec’, quello
utilizzato per generare il rapporto di ‘acua viewRec’.
login:
util:
online:
phone:
priority:
flags:
uflags:
maxLogins:
idleLimit:
time:
class:
data:
data TX:
data RX:
creation:
expiry:
lock:
subscr:
last log:
last on:
$login
$overallUtilization
$online
$phNo
$priority
[$flags]
[$uflags]
$maxLogins [maxDeduct = $maxDeduct]
[TTY = $idleLimit] [PPP = $PPPidleBytes bytes in $PPPidleMinutes]
total: [$tLeft + $credit / $tLimit] session: [$sLeft / $sLimit]
[$cLeft0 / $cLimit0] [$cLeft1 / $cLimit1] [$cLeft2 / $cLimit2]...
total: [$bXfer / $bLimit] session: [$bSxfer / $bSlimit]
total: [$bTx / $bTxLimit] session: [$bStx / $bStxLimit]
total: [$bRx / $bRxLimit] session: [$bSRx / $bSrxLimit]
$creationDate
$expireAction
$lockInfo
$subscriptionInfo
$lastLogin
$lastOnDays days [$lastOnline]
Si intuisce il senso delle variabili, anche se la maggior parte di queste non sono documentate.
/etc/smb.conf, 4369
8hz-mp3, 4383
Acua, 4386
acua addRec, 4396
acua addUser, 4396
acua delRec, 4402
acua delUser, 4396
acua expire, 4404
acua forEach, 4403
acua modRec, 4398
acua purge, 4404
acua renew, 4405
acua subscribe, 4401
acua sync, 4404
acua unsubscribe, 4402
acua viewRec, 4402
acua_adduser, 4393, 4396
acua_deluser, 4394, 4396
acua_login, 4404
acua_updated, 4403
controllo accessi, 4386
MP3, 4383
Mpg123, 4383
NetBIOS, 4366, 4371, 4374
nmbd, 4367, 4368
RIFF WAV, 4381
SMB, 4366
smbclient, 4372
smbmount, 4378
smbstatus, 4372
smbumount, 4380
Wavplay, 4381
wavplay, 4381
wavrec, 4381
WAV-RIFF, 4381
xanim, 4384
Xanim, 4384
xltwavplay, 4382
xltwavrec, 4382
4407
4408
Appunti di informatica libera 2003.01.01
Volume X
LDR: Linux domande e risposte
FAQ su GNU/Linux in italiano
Gaetano Paolone <[email protected]>
3.0 (2001.08.10)
4409
Gaetano Paolone è laureato in Odontoiatria e protesi dentaria ed esercita in qualità di libero
professionista in Roma. Nel tempo libero si dedica all’informatica ed in particolare a quella
libera.
Gaetano Paolone
LDR: Linux Domande e Risposte
Copyright © 1999-2001 Gaetano Paolone
bigpaul @ linuxfaq.it
This information is free; you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This work is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this work; if
not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Una copia della licenza GNU General Public License, versione 2, si trova nell’appendice A.
L’immagine di copertina è una realizzazione di Alessandra Toti. L’autore chiede che ogni
riproduzione cartacea dell’opera contenga questa immagine in copertina.
Nomi e marchi citati nel testo sono generalmente depositati o registrati dalle rispettive case
produttrici.
4410
non modificare
Dedicato a tutti coloro che si battono ogni giorno per l’affermazione del software libero...
4411
Le copie cartacee LDR: Linux Domande e Risposte sono reperibili nei centri GNUtemberg!.
I centri GNUtemberg! sono quei centri che vendono copie stampate di documentazione libera
non ancora ufficialmente pubblicata da case editrici. Presso <http://www.gnutemberg.org> o <http://
www.gnutenberg.org> sono reperibili più informazioni su questo progetto ed è reperibile anche un
elenco dei centri più vicini.
GNUtemberg!
4412
L’indirizzo della versione aggiornata delle LDR: Linux Domande e Risposte è:
<http://www.linuxfaq.it>
Riproduzioni aggiornate del sito suddetto sono inoltre disponibili presso i seguenti siti:
• Pluto (sezione ILDP):
<http://www.pluto.linux.it/ildp/LDR/>;
• inter.linux:
<http://linux.interpuntonet.it/linux/LDR/>;
• ziobudda.net:
<http://www.ziobudda.net/mirror/linuxfaq/>;
• king.rett.polimi.it/~ant/linuxfaq/:
<http://king.rett.polimi.it/~ant/linuxfaq/>;
Chiunque volesse mantenere una riproduzione aggiornata del sito delle LDR, può farlo
liberamente, eventualmente segnalandolo all’autore.
La versione 2000.04.12 di Appunti Linux di Daniele Giacomini ospita nell’ultimo tomo
dell’opera, il corpo della versione 2.4 delle LDR.
La versione 2000.07.31 di Appunti di Informatica Libera di Daniele Giacomini ospita negli ultimi
due tomi dell’opera, il corpo della versione 2.8 delle LDR free e nonfree.
LDR nei CD-ROM delle riviste:
• CD-ROM n° 52-1 inter.net (v. 1.8);
• CD-ROM 87-1 PC-Action (v. 2.2);
• CD-ROM n° 56-1 inter.net (v. 2.2);
• CD-ROM n° 1 Linux Magazine (v. 2.6);
• CD-ROM n° 13 Linux Magazine (v. 2.9);
• tutti i CD-ROM contenenti le versioni 2000.04.12 di Appunti Linux e 2000.07.31 di
Appunti di Informatica Libera.
La diffusione di questo documento è incoraggiata in base ai termini della licenza.
4413
388 Amministrazione del sistema
388.1 Installazione di GNU/Linux
388.1.1 Come si copiano o come si creano i dischetti di avvio (boot)?
388.1.2 Come si creano i dischetti di installazione di una distribuzione GNU/Linux
Debian?
388.1.3 Come si creano i dischetti di installazione di una distribuzione GNU/Linux
Red Hat da Dos?
388.1.4 Perché ‘FIPS.EXE’ non funziona all’interno di una finestra Dos?
388.1.5 Cosa significa il problema del limite dei 1024 cilindri?5
388.1.6 Perché dopo avere spostato il disco con MS-Windows e dopo averlo collocato
come primario slave, MS-Windows non parte più? Ho aggiornato le impostazioni
di LILO ma riesco ad avviare solamente GNU/Linux.
388.1.7 Come si fa a esportare il CD-ROM durante l’installazione via NFS?
388.2 Avvio e arresto del sistema
388.2.1 Come si arresta il sistema? Come si riavvia?
388.2.2 Come si disabilita il supporto per l’APM in fase di avvio?
388.2.3 È possibile fermare l’arresto o il riavvio del sistema dopo averne dato il
comando?
388.2.4 Esiste un modo per rendere più repentino l’arresto del sistema?
388.2.5 Come si concede a tutti gli utenti la possibilità di arrestare il sistema?
388.2.6 Come si concede a tutti gli utenti la possibilità di riavviare il sistema?
388.2.7 Come si può impedire agli utenti del sistema di impartire il riavvio mediante
la combinazione di tasti [ Ctrl+Alt+Canc ]?
388.2.8 Come funziona ‘install-mbr’ in una distribuzione GNU/Linux Debian?
388.2.9 Come è possibile avviare un sistema GNU/Linux da un sistema Dos/MSWindows?
388.2.10 Come si avvia GNU/Linux dal Boot Manager di MS-Windows NT?
388.2.11 Ho impostato involontariamente il livello di esecuzione (runlevel) a zero
e il sistema inizia la procedura di arresto non appena ha terminato l’avvio. Che
posso fare?
388.2.12 Come è possibile fare spegnere la macchina alla fine del processo di arresto?
388.2.13 Come è possibile far spegnere la macchina se si dispone di una scheda
madre ‘Soyo 5-EM’ o ‘Soyo 5 ema’?
388.2.14
È possibile avviare la procedura di arresto del sistema con una
combinazione di tasti?
388.2.15 Perché in alcune distribuzioni tutti gli utenti hanno la facoltà di impartire il
comando ‘halt’?
388.2.16 Come è possibile visualizzare messaggi o loghi all’avvio di GNU/Linux?
388.2.17 KERNEL PANIC: VFS: Unable to mount root fs on 03:03
388.2.18 Perché dopo la ricompilazione del kernel viene visualizzato un messaggio
di kernel panic?
388.2.19 swapon: warning: /dev/hda1 has insecure permissions 0660, 0600 suggest
388.2.20 Parallelizing fsck version x.yy /dev/hdxy: UNEXPECTED INCONSISTENCY; R
388.3 Tipi di file system e partizioni
5
questione risolta con le recenti versioni di LILO
4414
388.3.1 Come si fa a indicare che alcune directory del file system sono distribuite su
dispositivi differenti?
388.3.2 Come si visualizza la struttura del file system?
388.3.3 Come si crea un file system Ext2 nella terza partizione del secondo disco
fisso IDE/EIDE?
388.3.4 Come si verifica se ci sono settori danneggiati su partizioni con file system
Ext2?
388.3.5 Come si possono ridimensionare le partizioni con file system Ext2?
388.3.6 Come si può creare da GNU/Linux un file system Dos-FAT?
388.3.7
Come si verifica la presenza di settori danneggiati in una partizione
contenente un file system Dos-FAT?
388.4 Swap
388.4.1 Se si avesse bisogno di ulteriore spazio ‘swap’, come si aggiunge?
388.5 Montare i dischi
388.5.1 Operazioni con un dischetto Dos (file system vfat)
388.5.2 Non riesco a montare dischetti con file system Ext2; se uso dischetti con
file system Dos invece non ho problemi, perché?
388.5.3 Come si può montare una partizione con file system NTFS (MS-Windows
NT)?
388.5.4 Come si monta una partizione contenente MS-Windows 2000?
388.5.5 Come si fa a dare agli utenti il permesso di montare il lettore dischetti e il
lettore CD-ROM?
388.5.6 Ma cosa cambia se si mette ‘user’ o ‘users’ nei campi di ‘/etc/fstab’?
388.5.7 Come si concedono tutti i permessi di una partizione ad ogni utente del
sistema?
388.5.8 No final new line in /etc/fstab
388.5.9 Come si fa a montare automaticamente i dischi all’avvio?
388.5.10 Come è possibile montare le partizioni Dos/MS-Windows 9x (file system
vfat)?
388.5.11 Effettuando il login da un’altra console, si ottengono a volte numerosi
messaggi relativi a dispositivi già montati. Come si possono eliminare?
388.5.12 Come è possibile accedere a partizioni GNU/Linux (file system Ext2) da
MS-Windows?
388.6 LILO
388.6.1 Installazione e configurazione di LILO
388.6.2 Come posso avviare Linux con un dischetto di avvio, in maniera veloce?
388.6.3 Come si installa LILO in una posizione diversa da quella attuale?
388.6.4 Come si elimina LILO?
388.6.5 Come si fa a scegliere quale sistema operativo avviare in maniera predefinita
con LILO?
388.6.6 Come è possibile con LILO gestire più distribuzioni GNU/Linux sullo stesso
sistema?
388.6.7 Come si deve configurare LILO se sulla macchina è installato anche MSWindows NT?
388.6.8 Come si configura LILO se si vuole installare una distribuzione GNU/Linux
sul primo disco fisso e MS-Windows su un altro?
4415
388.6.9 Se si reinstalla MS-Windows, il MBR contenente LILO verrà sovrascritto;
come posso prevenire questo problema?
388.6.10 Come si può impostare una password per LILO?
388.6.11 Perché digitare «linux 1» al prompt di LILO consente l’accesso al sistema
senza richiesta di password?
388.6.12 ‘Error 0x10’ - visualizzazione di ripetuti 01 con LILO
388.6.13 Da cosa può dipendere se si riceve la segnalazione della presenza di un
virus nel settore di avvio (boot)?
388.6.14 Ci sono delle valide alternative a LILO?
388.7 Kernel
388.7.1 Come si può sapere quale è l’ultima versione del kernel?
388.7.2 Come si visualizza la versione del kernel in uso?
388.7.3 Come è possibile conoscere il nome del file dell’immagine del kernel che è
stata caricata?
388.7.4 Come si ricompila il kernel?
388.7.5 Come funziona la ricompilazione del kernel in una distribuzione GNU/Linux
Debian?
388.7.6 Cosa succede se copio la nuova immagine del kernel in ‘/boot’ ma lì c’è la
vecchia immagine?
388.7.7 Quanto spazio occupa il sorgente del kernel? Si può cancellare dopo la
ricompilazione?
388.7.8 Come si applica una patch al kernel?
388.7.9 Dopo avere applicato una patch al kernel, la procedura di ricompilazione
subisce dei cambiamenti?
388.7.10 Durante la ricompilazione del kernel, viene segnalata la mancanza di
‘wish’, perché?
388.7.11 Dopo avere ricompilato il kernel, come è possibile provare senza rischio
l’immagine appena creata?
388.7.12 Si può trasportare l’immagine del kernel da una distribuzione ad un’altra?
388.7.13 A cosa serve il file ‘initrd-x.x.xx.img’ nella directory ‘/boot’?
388.7.14 Il kernel di Linux è in grado di gestire periferiche USB?
388.7.15 Come è possibile ottimizzare il kernel per macchine con processore
Pentium?
388.7.16 Dove si trovano i sorgenti del kernel?
388.7.17 Perché sopraggiungono dei problemi relativi a ‘ipfwadm’ con i kernel della
serie 2.2.x ?
388.7.18 Perché nei kernel della serie 2.2.x non è presente l’opzione drop sourcerouted frames?
388.7.19 Come si verifica quali sono i pacchetti RPM del kernel installati?
388.7.20 Come si possono memorizzare gli eventuali messaggi (di errore e non) che
possono risultare dalla procedura di ricompilazione del kernel?
388.7.21 Perché dopo la ricompilazione del kernel c’è una diminuzione dello spazio
nel disco?
388.7.22 Dove devo copiare il file ‘System.map’ e che operazioni devo compiere su
di esso?
388.7.23 Come si possono gestire più file ‘System.map’ quando si dispone di più
immagini del kernel?
4416
388.7.24 Perché il sistema mi avverte che la versione del file ‘System.map’ è
sbagliata?
388.7.25 as86 Command not found
388.7.26 /dev/lp0 :not detected
388.7.27 signal 11
388.7.28 No setup Signature found
388.8 Moduli
388.8.1 Cosa si deve fare per i moduli dopo la ricompilazione del kernel?
388.8.2 Come si possono caricare i moduli del kernel all’avvio?
388.8.3 modprobe: can’t locate module...
388.9 Configurazione del sistema
388.9.1 Come è possibile mantenere sulla propria macchina più di una distribuzione
GNU/Linux?
388.9.2 Esiste la deframmentazione in GNU/Linux?
388.9.3 Quali sono le differenze tra i file ‘/etc/profile’, ‘~/.bashrc’, ‘~/
.bash_profile’ e ‘~/.inputrc’?
388.9.4 Come si rendono disponibili anche per gli utenti le modifiche fatte al file
‘/etc/bashrc’?
388.9.5 Dopo aver modificato un file di configurazione, è necessario riavviare il
sistema per rendere effettive le modifiche?
388.9.6 Perché alcune modifiche apportate al sistema durante situazioni di emergenza
non sono riscontrabili al riavvio?
388.9.7 Come vengono gestiti i servizi in una distribuzione GNU/Linux Debian?
388.9.8 Come si lancia un programma durante la fase di avvio di una distribuzione
GNU/Linux Debian?
388.9.9 Come vengono gestiti i servizi in una distribuzione GNU/Linux Red Hat?
388.9.10 Come si possono disattivare i servizi in Red Hat?
388.9.11
Come si fanno ripartire i demoni se si sono modificati i file di
configurazione?
388.9.12 Come si cambia il nome della macchina?
388.9.13 Come si imposta l’orologio?
388.9.14 Come si mantiene aggiornato l’orologio?
388.9.15 Cosa si deve fare per impostare l’ora legale in GNU/Linux?
388.9.16 Come si visualizza un calendario?
388.9.17 Come è possibile attivare ad ogni avvio la spia della tastiera relativa al tasto
[ BlocNum ]?
388.9.18 Si può cancellare il contenuto della directory ‘/tmp/’ o è pericoloso?
388.9.19 Come si visualizza lo spazio disponibile su disco?
388.9.20 Come si possono visualizzare le variabili d’ambiente?
388.9.21 Come si impostano le variabili d’ambiente?
388.9.22 Come si possono visualizzare le librerie usate da un programma?
388.9.23 Come mi devo comportare se un applicativo mi chiede una libreria di una
versione più vecchia di quella attualmente installata nel mio sistema?
388.9.24 C’è un modo per evitare di scrivere ogni volta comandi molto lunghi
utilizzati di frequente?
388.9.25 Esiste la possibilità di sospendere (ibernare) un sistema GNU/Linux?
4417
388.10 Utenti e password
388.10.1 Dove sono raccolte le informazioni sugli utenti del sistema?
388.10.2 Dove sono raccolte le informazioni sui gruppi di utenti del sistema?
388.10.3 In che modo è possibile rimuovere un account di un utente?
388.10.4 Come si cancellano tutti i file di un utente presenti nel sistema?
388.10.5 Come si fa a diventare momentaneamente un altro utente?
388.10.6 Come si cambia la propria password?
388.10.7 Come si cambia la password degli utenti del sistema?
388.10.8 Cosa sono le password shadow?
388.10.9 Come si può evitare la richiesta della password all’avvio?
388.10.10 Come si può evitare la richiesta del login e della password all’avvio?
388.10.11 Cosa si deve fare se si dimentica la password di ‘root’?
388.10.12 A cosa serve il file ‘/etc/.pwd.lock’?
388.10.13 Come si fa a sapere chi è connesso attualmente al sistema?
388.10.14 Come si cambia proprietario di un file?
388.10.15 Come si cambia il gruppo di un file?
388.11 Permessi
388.11.1 Come si conferisce il permesso di esecuzione ad un file?
388.11.2 Come si conferisce il permesso di lettura ad un file?
388.11.3 Come si conferisce il permesso di scrittura ad un file?
388.11.4 Come si conferiscono i permessi alle directory?
388.11.5 Qual è il significato del permesso di esecuzione di una directory?
388.11.6 Come posso concedere i permessi di lettura e scrittura su partizioni vfat agli
utenti del sistema?
388.11.7 Come si impostano i permessi predefiniti dei file e delle directory?
388.12 File, collegamenti (link) e directory
388.12.1 Come si copiano i file?
388.12.2 Come si cancellano i file?
388.12.3 Come si spostano i file?
388.12.4 Qual è in GNU/Linux l’equivalente di ‘DIR *.HTML /S’ del Dos?
388.12.5 Come si può evitare la cancellazione di un file da parte dell’utente ‘root’?
388.12.6 Come si esegue la copia di un’intera porzione del file system?
388.12.7 Esiste la funzione undelete in GNU/Linux?
388.12.8 In che posizione del file system mi trovo?
388.12.9 Come si visualizza il contenuto di un file?
388.12.10 Come si visualizza la riga numero n di un file?
388.12.11 Come si visualizza il contenuto di una directory?
388.12.12 Come si visualizza il contenuto di una directory a colori?
388.12.13 Come si visualizza il contenuto della directory corrente e delle sue
discendenti compreso di percorso?
388.12.14 Come si visualizza il contenuto di tutti i file di una directory?
388.12.15 Come si visualizza il contenuto di uno stesso file presente in diverse
directory?
388.12.16 Perché ‘less’ disattiva la colorazione di ‘ls’?
388.12.17 Come si crea un file vuoto?
4418
388.12.18 Come si uniscono più file di testo?
388.12.19 Come si fa a conoscere il tipo di un file?
388.12.20 Come si può mettere il contenuto di un file in ordine alfabetico?
388.12.21 Come si creano le directory?
388.12.22 Come si cancellano le directory?
388.12.23 Cosa sono gli attributi estesi? È vero che se conferiti ad un file, ne
impediscono la cancellazione anche da parte dell’utente ‘root’?
388.12.24 Come ci si sposta tra le directory del file system?
388.12.25 Quali sono le differenze tra collegamenti soft e hard?
388.12.26 Come si crea un collegamento simbolico?
388.12.27 Come si fa a trovare un file in tutto il file system?
388.12.28 Come si fa a trovare un file in una porzione del file system?
388.12.29
Con che comando posso copiare un file dopo averlo ricercato nel
file system?
388.12.30 Quali sono i file della directory corrente che contengono una stringa?
388.12.31 Quali sono i file del file system che contengono una stringa?
388.12.32 Come si visualizzano i nomi dei file che iniziano con una determinata
stringa?
388.12.33 Come si possono suddividere in più parti i file di grandi dimensione?
388.13 Configurazione della console
388.13.1 Come si utilizzano le variabili nella shell Bash?
388.13.2 Come si può personalizzare il prompt?
388.13.3 Esempi di prompt
388.13.4 Come si disabilita una console virtuale?
388.13.5 Che significato hanno gli apici inversi (‘) nella shell?
388.13.6 Come funziona ‘history’, lo storico dei comandi?
388.13.7 Come si possono reindirizzare i messaggi di ‘/dev/console’ su un’altra
console?
388.13.8 Come si può impostare la modalità grafica della console?
388.13.9 shell-init: could not get current directory: getcwd: cannot access par
388.14 File di log
388.14.1 Come si visualizzano i registri (log) degli accessi?
388.14.2 Di chi si occupa della registrazione degli eventi del sistema?
388.14.3 Come si possono ricavare informazioni dai file di log?
388.14.4 Si può creare uno script che riduca i file di log?
388.14.5 Si possono inviare i file di log attraverso la posta elettronica?
388.14.6 Come si può ridimensionare ‘/var/log/wtmp’?
388.14.7 Come si reindirizza lo standard error?
388.14.8 Come si possono visualizzare i messaggi che appaiono all’avvio del
sistema?
388.15 Cron e At
388.15.1
388.15.2
388.15.3
388.15.4
Come si verifica se Cron è attivo?
Come si attiva Cron?
Quali sono i file di configurazione del Cron?
Come si modificano i file crontab?
4419
388.15.5 Come sono strutturati i file crontab?
388.15.6 Come si visualizzano i file crontab?
388.15.7 Come si cancellano i file crontab?
388.15.8 Come si modificano i file crontab dell’utente ‘tizio’?
388.15.9 Cosa succede se Cron è installato, ma la macchina è spenta?
388.15.10 Si può utilizzare At con applicazioni X?
388.16 Processi ed utilizzo delle risorse del sistema
388.16.1 Perché spesso si nota un improvviso aumento dell’attività del disco fisso e
un conseguente rallentamento delle prestazioni del sistema?
388.16.2 Come si ottengono informazioni sulle risorse del sistema?
388.16.3 Quanta memoria e quante risorse sta utilizzando un processo?
388.16.4 Cosa è un ‘fork’?
388.16.5 Cosa è il PID dei processi?
388.16.6 Come si visualizzano i programmi che attualmente sono in esecuzione e
come si interrompono?
388.16.7 Come si fa a sapere il PID del processo che tiene occupato un dispositivo?
388.16.8 Come si fa a chiudere un’applicazione bloccata?
388.17 Risoluzione di problemi di una certa entità
388.17.1 Storia di un recupero della tavola delle partizioni
388.18 Caratteri speciali
388.18.1 Come si fanno le parentesi graffe?
388.18.2 Come si fa la tilde?
388.19 Documentazione di aiuto
388.19.1 Come si possono ricercare parole chiave nelle pagine di manuale (man)?
388.19.2 Come si convertono le pagine di manuale in PostScript?
388.19.3 Come si stampano le pagine di manuale?
389 Reti e rete Internet
389.1 Generalità e configurazione di una rete locale
389.1.1 Come si imposta un dominio virtuale?
389.1.2 Come si può controllare il traffico giornaliero del sistema?
389.1.3 Come si abilita il masquerading in una rete locale?
389.1.4 Come si predispone un firewall?
389.1.5 Perché non riesco ad uscire dalla rete locale attraverso il gateway? Ho
configurato tutto con attenzione ma non ci riesco. Perché?
389.2 FTP
389.2.1 Come si può fornire agli utenti solamente l’accesso FTP al sistema ma non
un accesso Telnet?
389.2.2 Come si può impedire l’accesso tramite FTP ad alcuni utenti?
389.2.3 Dopo essersi connessi ad un sistema remoto, come si fa a mantenere attivo
un comando FTP una volta disconnessi dal sistema stesso?
389.2.4 Come si può realizzare un comando che invii ogni minuto un file via FTP?
389.2.5 Come si concede il permesso di caricare file durante una sessione FTP?
389.2.6 Descrizione di uno script che permette di automatizzare diverse operazioni
FTP.
4420
389.3 Telnet
389.3.1 Come si può visualizzare cosa digita un utente collegato in Telnet?
389.3.2 Si può permettere l’accesso Telnet al proprio sistema anche mediante un’altra
porta?
389.3.3 Si può accedere ad una macchina solo da un terminale remoto?
389.3.4 Ci si può collegare attraverso Telnet a una macchina remota accedendo come
utente ‘root’?
389.3.5 C’è un’alternativa più sicura a Telnet?
389.3.6 Perché alcuni servizi di rete (Telnet, FTP, ecc.) sono molto lenti?
389.3.7 Si possono automatizzare dei comandi da eseguire su un sistema remoto cui
si abbia accesso attraverso Telnet?
389.3.8 Come funziona la registrazione degli accessi avvenuti tramite Telnet alle
macchine?
389.3.9 Come si impedisce l’accesso al sistema tramite Telnet?
389.4 SSH
389.4.1 Come si copiano i file con SSH?
389.4.2 Come si copiano intere porzioni di file system (directory) con SSH?
389.5 La condivisione delle risorse in rete
389.5.1 Perché non riesco a montare i file system delle macchine di una rete locale?
389.5.2 Come si fa ad utilizzare un’applicazione grafica (che giri sotto il server X)
presente su una macchina della rete cui è collegata la propria macchina?
389.5.3 Come si può utilizzare il display di un utente su quello di un altro?
389.5.4 Come si copiano i file tra le macchine di una rete locale?
389.6 Terminali
389.6.1 Come si possono simulare dei terminali sulla propria macchina?
389.6.2 terminal type not supported
389.7 Server web (Apache, ecc.)
389.7.1 Perché il mio navigatore non interpreta affatto i tag (marcatori) HTML dei
file presenti nel mio server?
389.7.2 Come vengono gestite le variabili tra due pagine PHP?
389.7.3 Come si configura il server Apache per gestire le pagine scritte in PHP?
389.7.4 Come si configura il server Apache per gestire le pagine scritte in ASP?
389.7.5 Esiste un modo per convertire le pagine scritte in ASP in PHP?
389.7.6 Come si fa a proteggere alcune pagine HTML da una password?
389.8 Samba
389.8.1 Quale password deve essere inserita se si accede attraverso Samba da una
macchina MS-Windows a una GNU/Linux?
389.8.2 Qual è un esempio di ‘smb.conf’ ben configurato?
389.8.3 Come si ricevono i messaggi di WinPopUp con LinPopUp?
389.8.4 Perché non si vedono le icone delle macchine GNU/Linux in ‘Risorse di
Rete’ di MS-Windows?
389.8.5 Come si copiano i file tra una macchina GNU/Linux e una MS-Windows
collegate attraverso Samba?
389.8.6 Come si fa a stampare da una macchina GNU/Linux collegata ad una rete
MS-Windows tramite Samba?
4421
389.8.7 Se ci si collega da una macchina MS-Windows ad una GNU/Linux, vorrei che
venisse chiesta la password solo per le directory degli utenti e non per la directory
indicata in ‘[public]’. Come si fa?
389.8.8 Come si deve configurare il file ‘smb.conf’ per dare un nome mediante
il name server NetBIOS alla macchina Linux collegata ad una rete servita da un
server DHCP?
389.9 Plip
389.9.1 Come si imposta il MTU (Max Transfer Unit ) di una connessione tramite
protocollo PLIP?
389.10 Connessione al provider - ppp
389.10.1
Esiste un programma che faciliti la connessione al provider in una
distribuzione GNU/Linux Debian?
389.10.2 Come si può verificare se nel sistema è stato installato il protocollo PPP?
389.10.3 Come si possono visualizzare in tempo reale i processi di connessione al
provider?
389.10.4 pppd: The remote system is required to authenticate itself but...
389.10.5 Si possono ottenere dei dati sulla connessione ad Internet?
389.10.6 Perché durante l’avvio di ‘kppp’ ( KDE 2.x ) viene visualizzato un errore
relativo al timeout?
389.10.7 Perché ‘kppp’ (KDE 2.x ) non riesce a creare il file di lock?
389.10.8 Perché lanciando da utente ‘kppp’ (KDE 2.x ), viene chiesta la password
di ‘root’?
389.10.9 Come può un utente qualsiasi utilizzare ‘kppp’ (KDE 2.x )?
389.10.10 Come si visualizza il proprio indirizzo IP?
389.10.11 Si può estrapolare solamente l’indirizzo IP da ‘ifconfig’?
389.10.12 Come si ottengono gli indirizzi DNS dei provider?
389.10.13 Se ci si connette ad Internet con più di un provider, occorre cambiare ogni
volta gli indirizzi DNS nel file ‘/etc/resolv.conf’?
389.10.14 Cosa si deve fare se il provider assegna automaticamente gli indirizzi
DNS?
389.10.15
Perché pur essendo connessi a Internet il navigatore non riesce a
connettersi ai siti?
389.10.16 no dialtone
389.10.17 Come si possono automatizzare alcune operazioni da effettuare durante la
connessione ad Internet?
389.10.18 Come ci si connette ad Internet con gli script?
389.10.19 Esempio degli script per la connessione ad un provider
389.10.20 Perché in Red Hat viene composto due volte il numero telefonico del
provider?
389.10.21 Perché utilizzando ‘ppp’ per il collegamento ad Internet, compare una
casella di dialogo che avverte che il demone ‘pppd’ non è installato con il set user
ID? Che vuol dire?
389.10.22 Perché il collegamento ad Internet con ‘diald’ fallisce per problemi di
autentificazione?
389.10.23 Una volta essere riusciti ad aver stabilito un collegamento funzionante ad
Internet, quali sono i file di configurazione e gli script che conviene conservare?
389.10.24 Perché utilizzando il ‘dialup configuration tool’ della Red Hat 6.1
il sistema si blocca?
4422
389.10.25 Se si utilizzano diversi provider per connettersi ad Internet, come si
possono invertire rapidamente gli script di connessione in una distribuzione
Red Hat?
389.10.26 Se si utilizzano diversi provider per connettersi ad Internet, come si
possono gestire gli script di connessione?
389.11 Connessione remota tra macchine
389.11.1 Come si predispone un accesso da linea commutata a una macchina
GNU/Linux?
389.11.2 Come ci si sconnette da un sistema remoto lasciando attivi alcuni processi?
389.12 Posta elettronica
389.12.1 Come si configura il sistema per poter scaricare e smistare i messaggi di
posta elettronica?
389.12.2 Come si configura Fetchmail?
389.12.3 Come si possono spedire messaggi all’interno di una rete locale facendo
risultare un indirizzo esterno?
389.12.4 Come si indirizzano correttamente i messaggi scaricati con Procmail in una
directory ben precisa?
389.12.5 Come si installa e come si configura Postfix?
389.12.6 You have new mail
389.12.7 Perché la macchina esita a lungo su Sendmail all’avvio?
389.12.8 Qual è l’indirizzo cui fare ‘telnet’ per verificare la configurazione di
Sendmail nei confronti dello spam?
389.12.9 Come si può inviare un file di testo compresso in allegato con un unico
comando?
389.12.10 Come si può associare un file di testo ad un messaggio da riga di comando?
389.12.11 Come si possono inviare messaggi ad intervalli di tempo regolare?
389.12.12 Come si possono eliminare i duplicati di posta elettronica?
389.12.13 Cosa è il file ‘~/.forward’?
389.12.14 Si può scegliere la firma (signature) in modo casuale?
389.12.15 Perché i client di posta delle macchine di una rete locale non riescono ad
inviare i messaggi al di fuori della rete stessa?
389.12.16 Come si scarica la posta con Mutt?
389.12.17 Come si spedisce con Mutt un file allegato da riga di comando?
389.12.18 Come si personalizza in Mutt, la stringa che introduce il messaggio
riportato?
389.12.19 Come si configura in Mutt, la stringa che indica il vecchio oggetto del
messaggio in caso di sostituzione dello stesso?
389.12.20 Come si può automatizzare lo scaricamento della posta?
389.13 Navigatori (browser)
389.13.1 Come si imposta lo sfondo di Lynx?
389.13.2 Come si ricarica una pagina (reload) con Lynx?
389.14 Gruppi di discussione (newsgroup)
389.14.1 Leafnode - Come si possono leggere i messaggi dei gruppi di discussione
una volta scollegati?
389.14.2 skipping it.xxx.yyy from now on
389.15 IRC - chat
4423
389.15.1 Come si possono controllare le intrusioni al sistema che possono verificarsi
con frequenza durante l’utilizzo di programmi per IRC?
389.16 Scaricamento file - riproduzione (mirror) di siti
389.16.1 Quali sono i programmi per GNU/Linux che si devono utilizzare per
scaricare i file ad intervalli?
389.16.2 Come si riprende con Wget uno scaricamento interrotto?
389.16.3 Come si riprende uno scaricamento interrotto da un sito FTP?
389.16.4 Come si crea una riproduzione speculare (mirror) di un sito?
389.16.5 Come si fornisce utente e password a Wget per scaricare un file da un sito
FTP?
389.16.6 Si può utilizzare Wget con i proxy?
389.16.7 Come si può automatizzare lo scaricamento di file in orari particolari?
390 Programmi
390.1 Installazione ed esecuzione programmi
390.1.1 Come si installano i programmi?
390.1.2 Come si evita di mettere sempre ‘./’ davanti al nome di un eseguibile?
390.1.3 Come si fa a non far chiudere i programmi lanciati da un terminale grafico
alla chiusura del terminale stesso?
390.1.4 Come si fa a chiudere il terminale grafico nel momento del lancio di un
eseguibile o di un’applicazione?
390.1.5 Dove risiedono realmente nel file system gli eseguibili?
390.1.6 Come si applicano le patch (file delle differenze) ai programmi?
390.1.7 Cosa sono i file ‘.elf’?
390.1.8 È possibile far girare alcune applicazioni di SCO Unixware con Linux?
390.1.9 Dove viene posizionata all’interno del file system la documentazione allegata
ai pacchetti?
390.2 File ‘core’
390.2.1
390.2.2
390.2.3
390.2.4
Cosa sono i file ‘core’?
Come si evidenzia il responsabile di un file ‘core’?
Si possono disabilitare i file ‘core’?
Come si eliminano tutti i file ‘core’?
390.3 I pacchetti - generalità
390.3.1
390.3.2
390.3.3
390.3.4
Come si convertono i pacchetti?
Come si possono utilizzare pacchetti RPM in una distribuzione Slackware?
Come si possono convertire i pacchetti ‘tar.gz’ in formato RPM?
Cosa sono i file ‘.bin’?
390.4 I pacchetti - ‘tar.gz’, ‘tgz’
390.4.1
390.4.2
390.4.3
390.4.4
390.4.5
Come si installano i programmi distribuiti in pacchetti ‘.tar.gz’ (o ‘.tgz’)?
Che differenza c’è tra i pacchetti ‘.tar.gz’ e i pacchetti ‘.tgz’?
Come si visualizza il contenuto dei pacchetti ‘.tar.gz’ o ‘.tgz’
Come si decomprimono i pacchetti ‘.tar.gz’ o ‘.tgz’?
Come si disinstallano i programmi originariamente installati da pacchetti
‘.tar.gz’ o ‘.tgz’?
390.4.6 Come si creano i propri pacchetti ‘.tar.gz’ o ‘.tgz’?
4424
390.4.7 Come si creano pacchetti ‘.tar.gz’ o ‘.tgz’ nel cui nome venga inserita la
data di creazione?
390.4.8 Come si creano i pacchetti ‘.tar.gz’ o ‘.tgz’ sequenziali su dischetti?
390.4.9 Come si ripristinano i pacchetti ‘.tar.gz’ o ‘.tgz’ archiviati su dischetti
sequenziali?
390.5 I pacchetti - ‘deb’
390.5.1 Come si installano i pacchetti Debian?
390.5.2 Come si aggiornano i pacchetti Debian?
390.5.3 Come si disinstallano i pacchetti Debian?
390.5.4 Come si verifica l’installazione dei pacchetti Debian?
390.5.5 Da quale pacchetto Debian proviene un determinato file?
390.5.6 Come si fa a conoscere le dipendenze di un pacchetto Debian installato?
390.5.7 Come si fa ad ottenere la descrizione e l’elenco del contenuto dei pacchetti
Debian?
390.5.8 Come si visualizza l’elenco dei pacchetti Debian installati?
390.5.9 Come funziona Dselect?
390.5.10 Come funziona ‘apt-get’?
390.6 I pacchetti - RPM
390.6.1 Come si installano i pacchetti RPM?
390.6.2 Come si aggiornano i pacchetti RPM?
390.6.3 Come si disinstallano i pacchetti RPM?
390.6.4 Come si verifica l’installazione di pacchetti RPM?
390.6.5 Da qual pacchetto RPM viene un determinato file?
390.6.6 Come si ottiene una descrizione di un pacchetto RPM?
390.6.7 Come si visualizza l’elenco dei pacchetti RPM installati?
390.6.8 Come si verifica la corretta installazione di tutti i pacchetti?
390.6.9 Come si può verificare la corrispondenza tra un pacchetto RPM e ciò che è
installato?
390.6.10 Come si può installare un pacchetto RPM su destinazione diversa da quella
predefinita?
390.7 La compressione - ‘.gz’ ‘.bz2’ ‘.zip’
390.7.1 Come si comprime un file?
390.7.2 Cosa è un file ‘.gz’?
390.7.3 Cosa è un file ‘.bz2’?
390.7.4 Avendo una serie di file compressi con ‘gzip’, come posso decomprimerli
tutti evitando di utilizzare ‘gunzip’ per ognuno?
390.7.5 Cos’è un file ‘.tar.bz2’ e come posso utilizzarlo?
391 X
391.1 Avvio, conclusione, configurazione e risoluzione
391.1.1 Come si cambia desktop manager in una distribuzione GNU/Linux Red Hat?
391.1.2 Come si fa a sapere la versione del server X?
391.1.3 Come si abilita e disabilita il login grafico?
391.1.4 Come si abilita e disabilita il login grafico di una distribuzione GNU/Linux
Debian?
4425
391.1.5 Perché l’utente ‘root’ non riesce a lanciare applicazioni grafiche se il server
X è stato lanciato da utente comune?
391.1.6 Come si può lanciare un’applicazione che gira sotto X senza attivare il
gestore delle finestre?
391.1.7 Come si lancia solamente X, senza gestori delle finestre?
391.1.8 Come si possono catturare le immagini in GNU/Linux?
391.1.9 Come si fa se i caratteri appaiono troppo piccoli in X ad alte risoluzioni?
391.1.10 Come si può risolvere il blocco di X senza riavviare il sistema?
391.1.11 C’è un modo per aumentare le prestazioni del server X?
391.1.12 Come si possono capire gli errori del server X?
391.1.13 Come si imposta la risoluzione predefinita di X?
391.1.14 Come si regola la profondità dei colori in X?
391.1.15 Come si elimina lo schermo virtuale?
391.1.16 Come si passa da una modalità all’altra dello schermo virtuale?
391.1.17 L’immagine in X è decentrata, come posso risolvere questo problema?
391.1.18 Come si apre una console testuale da X?
391.1.19 Come si ritorna alla console grafica (X) dopo avere aperto una console
testuale?
391.2 Gnome
391.2.1 Come si chiude contemporaneamente Enlightenment e ‘gnome-panel’?
391.2.2 Come si configura in Gnome l’associazione tra file HTML e le applicazioni
deputate a visionarle?
391.3 X - Gestori delle finestre (window manager)
391.3.1
391.3.2
391.3.3
391.3.4
391.3.5
391.3.6
Come si impostano i temi di Enlightenment?
Come si richiamano le finestre nascoste in Window Maker?
Come si impostano i temi di Window Maker?
Come si configura IceWM?
Come si aggiungono pulsanti sulla barra di IceWM?
Come si imposta lo sfondo di IceWM?
391.4 Terminale grafico (‘xterm’)
391.4.1 Perché le applicazioni lanciate da un terminale grafico scompaiono alla
chiusura del terminale stesso?
391.4.2 Come è possibile conferire le stesse impostazioni della console testuale ai
terminali grafici?
391.4.3 Come si fa a lanciare un’applicazione da terminale grafico dopo avere assunto
l’identità di un altro utente?
391.4.4 Come si impostano i colori del terminale grafico?
391.4.5 Come si impostano in maniera predefinita i colori del terminale grafico?
391.4.6 Perché non funzionano più i terminali grafici?
391.4.7 Come imposto il comportamento del tasto [ Canc ] nel terminale grafico?
391.4.8 Come funziona il ‘copia ed incolla’ in X?
392 Applicazioni
392.1 Editor di testi
392.1.1 Quali sono i comandi essenziali di VI?
4426
392.1.2 Come si configura il numero di caratteri per riga di ‘elvis’ (‘vi’)?
392.2 Applicazioni per comunicazioni telefoniche
392.2.1 Come si cambiano le impostazioni di Minicom?
392.3 Applicazioni fax
392.3.1 ‘no dialtone’ con Efax
392.4 Applicazioni grafica bidimensionale non vettoriale
392.4.1 Come si convertono i file ‘.gif’ in ‘.png’?
392.5 Applicazioni matematiche
392.5.1 Ci sono per GNU/Linux programmi per la matematica, per fare grafici?
392.6 Applicazioni base di dati (database)
392.6.1 Quali sono le differenze tra DB e DBMS?
392.6.2 Perché durante la compilazione di PHP per il supporto di PostgreSQL mi
vengono richieste le librerie ‘libpq’?
392.6.3 Unable to connect to PostgresSQL server: connectDB() failed: Is the pos
392.6.4 Perché non tutti gli utenti possono creare archivi PostgreSQL?
392.6.5 Come si possono esportare basi di dati da Microsoft Access a PostgreSQL?
392.6.6 Come si creano gli archivi con PostgreSQL?
392.6.7 Come si fa ad accedere ad un archivio con PostgreSQL?
392.6.8 Unsupported frontend protocol
393 Stampa
393.1 Impostazioni generali
393.1.1
393.1.2
393.1.3
393.1.4
393.1.5
393.1.6
393.1.7
393.1.8
Com’è strutturato il file ‘/etc/printcap’?
Perché non vengono trovati i dispositivi ‘/dev/lp?’?
Come si configura la stampante in una distribuzione GNU/Linux Red Hat?
Come si visualizza la coda di stampa?
Come si eliminano i processi di stampa in coda?
Come si elimina tutta la coda di stampa?
Come si evita l’effetto scalettato nella stampa di testi?
Come si evita la stampa dei separatori con il nome dell’utente?
393.2 Stampa da riga di comando
393.2.1 Come si stampa un file da riga di comando?
393.2.2 Come si stampa il contenuto della directory corrente?
393.2.3 Come si stampa un file PostScript da riga di comando?
394 Editoria
394.1 Conversione tra formati
394.1.1 Come si può convertire un file HTML in txt?
394.2 I file PostScript (‘.ps’)
394.2.1 Come si visualizzano i file PostScript in MS-Windows?
394.3 I file ‘.pdf’
394.3.1 Perché in GNU/Linux con Xpdf i file PDF vengono visualizzati male?
394.4 I File ‘.sgml’
4427
394.4.1 Perché con ‘sgml2txt’ si trovano spesso parole con lettere ripetute? Si tratta
di un’interpretazione scorretta?
394.5 I file ‘.doc’
394.5.1 Come si leggono e stampano i documenti Microsoft Word in GNU/Linux?
394.6 Compatibilità formati GNU/Linux-Dos
394.6.1 Perché aprendo con Emacs alcuni file di testo creati con programmi Dos,
compaiono una serie di ‘^M’ alla fine di ogni riga?
395 I Caratteri (font)
395.1 Impostazioni
395.1.1 Come si fa a cambiare i caratteri del prompt?
395.1.2 Removing unix/:7101 from the valid list of fontpaths
395.1.3 Come si possono utilizzare i caratteri TrueType con XFree86 4?
395.1.4 Come si utilizzano in Linux i caratteri TrueType (XFree86 3.xx)?
395.1.5
Da quale pacchetto derivano i file ‘FS.h’ e ‘FSprolo.h’? Risultano
mancanti durante la compilazione di ‘xfstt’?
395.1.6 Come si può richiamare ‘xfstt’ all’avvio di GNU/Linux?
396 Immagini
396.1 Generalità
396.1.1
396.1.2
396.1.3
396.1.4
396.1.5
396.1.6
Come si crea l’immagine di una partizione?
Come si crea l’immagine di un dischetto?
Come si copia un’immagine su un dischetto?
Come si visualizza il contenuto di un’immagine?
Come si può inserire file in un’immagine?
Si può aggiungere un file ad un’immagine ISO 9660?
397 Masterizzazione
397.1 Masterizzare da riga di comando
397.1.1
397.1.2
397.1.3
397.1.4
397.1.5
397.1.6
397.1.7
397.1.8
Quali sono i comandi comuni per masterizzare con GNU/Linux?
Come si masterizza in modalità multisessione?
Come si masterizza un CD-ROM audio?
Come si utilizza Cdda2wav per estrarre le tracce audio?
Come si masterizza on the fly?
Come si rende avviabile un CD-ROM?
Linux gestisce i CD riscrivibili?
Come si formatta un CD riscrivibile?
398 Audio
398.1 Impostazioni
398.1.1 Come si installano i moduli audio ALSA?
398.1.2 Perché non si sente nessun suono dopo l’installazione dei driver ALSA?
398.1.3 Come si alza il volume nelle macchine desktop e nei portatili se si utilizzano
i driver ALSA?
398.1.4 Come si regolano in maniera definitiva i toni del mixer?
4428
398.1.5 Come si possono eliminare le segnalazioni acustiche di sistema?
398.2 CD audio
398.2.1 Non riesco a montare i CD audio!
398.3 mp3, wav, ecc.
398.3.1 Quali sono le applicazioni da utilizzare per creare file ‘.mp3’ partendo da
brani presenti su CD?
398.3.2 Si possono creare file ‘.mp3’ dai brani presenti in un CD-ROM mediante un
comodo script?
398.3.3 Come si possono leggere i tag (marcatori) ‘ID3’ dei file ‘.mp3’?
399 Programmazione
399.1 Script per la shell
399.1.1 Perché il comando ‘cd’ non funziona negli script?
399.1.2 Come si può eseguire uno script di shell attraverso il protocollo HTTP?
399.1.3 Esiste un comando o un sistema per contare le righe presenti in un file di
testo?
399.1.4 Esiste un comando o un sistema per contare i caratteri presenti in un file di
testo?
399.1.5 Come si fa a sapere lo stato di uscita di un comando?
399.1.6 Che differenza c’è tra ‘$@’ e ‘$#’ all’interno degli script shell?
399.1.7 Come si eliminano le prime n righe o le ultime n righe per numerosi file di
testo?
399.1.8 Come si cancellano tutte le righe di un file che cominciano con una
determinata stringa?
399.1.9 Come si aggiungono i numeri di riga ad un file di testo?
399.1.10 Come si sceglie un file a caso in una directory?
399.1.11 Come si visualizzano i file modificati negli ultimi n minuti?
399.1.12 Come si ricercano file doppi?
399.1.13 Come si convertono in minuscolo tutti i nomi dei file di una directory?
399.1.14
Come si convertono in minuscolo i nomi dei file nei collegamenti
ipertestuali di una pagina HTML?
399.1.15 Come si converte un elenco di nomi di file ‘.html’ in collegamenti
ipertestuali?
399.1.16 Come si ordinano le righe di un file di testo al contrario?
399.1.17 Come si utilizza Sed per sostituire il testo?
399.1.18 Quante volte appare una parola in un file?
399.1.19 A cosa serve l’opzione ‘-f’ (if) negli script della shell?
399.1.20 Come si può utilizzare ‘date’ negli script della shell?
399.1.21 Come si fa a cercare tutti i file di un certo tipo (es. ‘*.png’) e a copiarli in
una directory?
399.1.22 Come si cambiano le estensioni dei file?
399.1.23 Come si può modificare l’output di ‘pppstats’?
399.1.24 Come si trovano tutti gli indirizzi di posta elettronica in un file HTML?
399.1.25 Come si aggiunge una stringa alla fine di ogni riga di un file testo?
399.1.26 Esempio di uno script per decomprimere file in directory sequenziali.
399.2 Linguaggio C
4429
399.2.1
399.2.2
399.2.3
399.2.4
Cosa sono i file ‘.h’, ‘.o’ e ‘.c’ in un programma C?
Come si avvia il compilatore C++?
Bus Error
Esiste in GNU/Linux il file ‘conio.h’?
399.3 Pascal
399.3.1 Si può convertire un programma scritto in Pascal in C?
399.4 Cobol
399.4.1 Esistono dei compilatori Cobol per GNU/Linux?
399.5 Perl
399.5.1 Come si installano i moduli Perl?
400 Computer portatili
400.1 Problematiche di installazione
400.1.1 Perché non funziona l’audio sul portatile Acer TM 312D?
400.1.2 Perché la tastiera del portatile alla fine dell’installazione di Linux risulta
inutilizzabile?
401 Hardware
401.1 Processori
401.1.1 Come si comporta il processore AMD K6 con Linux?
401.2 Monitor
401.2.1 Come si può impostare il risparmio energetico per il monitor?
401.3 Dispositivi video (scheda, telecamera, ecc.)
401.3.1
Sono supportate le schede TV e le schede di acquisizione video in
GNU/Linux?
401.3.2 Si può utilizzare la scheda video Matrox G200 AGP in GNU/Linux?
401.3.3 Si può utilizzare la scheda video SiS 6326 in GNU/Linux?
401.4 Tastiera
401.4.1
401.4.2
401.4.3
401.4.4
Come si possono utilizzare i tasti accessori della tastiera in GNU/Linux?
Come si imposta la tastiera italiana?
Come si impostano le tastiere estere?
È possibile generare i caratteri accentati su una tastiera statunitense?
401.5 Mouse
401.5.1 Come si configura un mouse PS/2?
401.5.2 Come si abilita l’utilizzo della rotellina del mouse?
401.6 Disco fisso
401.6.1 Perché i controller UltraATA non vengono riconosciuti?
401.7 CD-ROM e masterizzatori
401.7.1 Come si configura un CD-ROM esterno parallelo in GNU/Linux?
401.7.2 Perché ho problemi con il CD-ROM all’avvio del server X?
401.7.3 Come si configura un masterizzatore connesso all’interfaccia IDE/EIDE?
401.7.4 Qual è il nome del dispositivo generalmente associato a un masterizzatore
connesso all’interfaccia IDE/EIDE?
4430
401.7.5 Come si utilizza in GNU/Linux un masterizzatore SCSI?
401.7.6 Qual è il nome del dispositivo generalmente associato a un masterizzatore
SCSI?
401.8 Schede di rete
401.8.1 Come si utilizzano schede di rete NE2000 compatibili in GNU/Linux?
401.9 Scheda audio
401.9.1 Come si fa a rilevare le schede audio Plug & Play in GNU/Linux?
401.9.2 Come si fa a rilevare una scheda audio OPTi 82C931 presente su un
alloggiamento ISA?
401.9.3
Come si fa ad utilizzare una scheda audio Sound Blaster Live! con
GNU/Linux?
401.9.4 Perché il sistema restituisce un errore di ‘device busy’ relativo alla
SoundBlaster PCI 128?
401.9.5 Come si configura una SoundBlaster PCI 64V in GNU/Linux?
401.9.6 Come si configura una scheda audio Yamaha OPL3-SAx in GNU/Linux?
401.9.7 Come si configura una scheda Avance Logic ALS 110 in GNU/Linux?
401.9.8 Come si configura una scheda Plug & Play 16 bit ISA SoundBlaster
compatibile in GNU/Linux?
401.9.9 Come si fa riconoscere al sistema una scheda audio SoundBlaster 16 Plug &
Play?
401.9.10 Come si configurano i driver ALSA per le schede audio SoundBlaster PCI
64V integrate su scheda madre?
401.10 Lettori ZIP
401.10.1 Quale è il nome del dispositivo comunemente associato ad un lettore Iomega
ZIP ATAPI installato sul canale master della seconda interfaccia IDE/EIDE?
401.10.2 Come si deve configurare il sistema per far riconoscere un lettore ZIP
collegato alla porta parallela?
401.10.3 Quali sono le differenze tra i moduli ‘ppa’ e ‘imm’ dei drive ZIP?
401.11 Nastri
401.11.1 Come si utilizzano le unità a nastro DAT?
401.12 RAM
401.12.1 Quanta RAM è utilizzata e quanta è disponibile?
401.12.2 Come si dichiara la quantità di RAM oltre le 64 Mibyte in proprio possesso?
401.12.3 Perché la dichiarazione della quantità RAM superiore alle 64 Mibyte non
funziona?
401.12.4 Come si comporta il sistema se ci sono difetti nella RAM?
401.13 Scanner
401.13.1 Si può utilizzare uno scanner HP 6100C in GNU/Linux?
401.14 Modem
401.14.1 Si possono utilizzare i Win-modem in GNU/Linux?
401.14.2 Cosa si deve configurare per far riconoscere il modem al sistema?
401.14.3 Come si configura il sistema per utilizzare un dispositivo US Robotics ISDN
TA?
401.15 Stampante
4431
401.15.1 Quali sono le stampanti utilizzabili con GNU/Linux?
401.15.2 Come si può stampare con una HP Deskjet 720C?
401.15.3 Come si configura il file ‘/etc/printcap’ se si utilizza una stampante
Epson Stylus Color?
401.15.4 Cosa va impostato prima della ricompilazione del kernel per permettere al
sistema di stampare?
401.16 Periferiche SCSI
401.16.1
Come funziona l’emulazione SCSI per la gestione delle periferiche
IDE/EIDE/ATAPI?
401.16.2 Quale opzione del kernel bisogna selezionare se si possiede la scheda SCSI
Adaptec 2904?
401.16.3 Cosa si deve configurare per fare riconoscere al sistema il dispositivo SCSI
Adaptec 1510A?
Adaptec 1505?
Adaptec 152x?
401.17 Unità disco
401.17.1 Cosa si deve configurare per fare riconoscere al sistema un’unità LS-120
interna?
401.18 Periferiche Plug & Play
401.18.1 Come si fa ad utilizzare periferiche Plug & Play in GNU/Linux?
401.19 Porte (seriale, parallela, PS/2, USB, ecc.)
401.19.1
401.19.2
401.19.3
401.19.4
401.19.5
401.19.6
Come si ricreano i dispositivi ‘/dev/ttyS0’ e ‘/dev/ttyS1’?
Come si ricrea il dispositivo ‘/dev/dsp’?
Perché il sistema dice che i dispositivi ‘/dev/cuan ’ sono obsoleti?
Come si ricrea ‘/dev/null’?
Come si ricreano i dispositivi ‘/dev/lp*’?
Come si possono individuare gli indirizzi di IRQ e di I/O?
4432
Capitolo
388
Amministrazione del sistema
388.1 Installazione di GNU/Linux
388.1.1) Come si copiano o come si creano i dischetti di avvio (boot)?
Si può leggere il dischetto creando un’immagine in un file:
# dd if=/dev/fd0 of=floppy.img[ Invio ]1
Quindi si può utilizzare il file dell’immagine copiandolo in un altro dischetto già inizializzato a
basso livello:
# dd if=floppy.img of=/dev/fd0[ Invio ]
In alternativa si può usare ‘mkbootdisk’, per crearne uno nuovo, ecco un esempio per il kernel
2.2.7:
# mkbootdisk --device /dev/fd0 2.2.7[ Invio ]
Oppure ancora:
# cp bzImage /dev/fd0[ Invio ]2
Per indicare la partizione del disco fisso su cui dovrà essere montato il file system principale (‘/’)
si deve utilizzare il comando ‘rdev’:
# rdev /dev/fd0 /dev/partizione [ Invio ]3
Infine occorre ricordarsi di impostare nel BIOS l’avvio da dischetto.
388.1.2) Come si creano i dischetti di installazione di una distribuzione GNU/Linux
Debian?
Come per i dischetti della distribuzione Red Hat, ‘RAWRITE.EXE’ è un comando valido per
copiare qualsiasi immagine di dischetto. Nella distribuzione GNU/Linux Debian si può trovare ‘RAWRITE.EXE’ nella directory ‘\TOOLS\RAWRITE2\’ (meglio usare la versione 2), mentre
le immagini dei dischetti si trovano in ‘\DISTS\STABLE\MAIN\DISKS-I386\CURRENT\’. Il
numero di dischetti da usare dipende dal metodo di installazione.
388.1.3) Come si creano i dischetti di installazione di una distribuzione GNU/Linux
Red Hat da Dos?
Si deve usare il programma ‘RAWRITE.EXE’ presente nella directory ‘\I386\DOSUTILS\’ della
distribuzione che hai. Il comando è:
1
2
‘floppy.img’ rappresenta il nome dell’immagine che verrà creata.
‘bzImage’ rappresenta il nome dell’immagine del kernel che verrà copiata sul dischetto. Si è scelto ‘bzImage’ come
esempio perché è il nome dell’immagine che risulta alla fine della procedura di ricompilazione del kernel e che si viene
generalmente a trovare in ‘/usr/src/linux/arch/i386/boot’ nei computer con architettura i386.
3
Per partizione si intende la partizione in cui abbiamo intenzione di installare il file system principale (es. ‘hda1’,
‘hdb5’, ecc.)
4433
4434
D:\> RAWRITE immagine A:[ Invio ]
La metavariabile immagine rappresenta il nome del dell’immagine presente in ‘\I386\
IMAGES\’. I file sono due per creare i due dischetti. La terza immagine è per la risoluzione
dei problemi di installazione.
388.1.4) Perché ‘FIPS.EXE’ non funziona all’interno di una finestra Dos?
‘FIPS.EXE’ deve essere lanciato da Dos puro, non da emulazione MS-Windows. Si deve innan-
zitutto eseguire la deframmentazione del disco fisso e riavviare poi in modalità Dos in seguito si
esegue ‘FIPS.EXE’ seguendo le istruzioni.
È consigliabile leggere con attenzione la documentazione di ‘FIPS.EXE’, che dovrebbe trovarsi insieme all’eseguibile, facendo comunque fare le copie di sicurezza del contenuto del
disco di MS-Windows (o almeno dei file non recuperabili in altri modi).
388.1.5) Cosa significa il problema del limite dei 1024 cilindri?4
Al momento di suddividere in partizioni il disco con l’uso di ‘fdisk’ può capitare di vedere la
segnalazione di un errore simile a quello seguente:
The number of cylinders for this disk is set to 2105.
This is larger than 1024, and may cause problems with:
1) software that runs at boot time (e.g. LILO)
2) booting and partitioning software from
other OSs (e.g. DOS FDISK, OS/2 FDISK)
Non è il caso di preoccuparsi; più che un errore è un avvertimento sul fatto che alcuni programmi
(LILO) o sistemi operativi non sono in grado di accedere ai cilindri oltre il 1024-esimo (il numero
1023) per problemi del BIOS.
Si possono attuare gli accorgimenti seguenti:
1. attivazione della modalità LBA del BIOS, che traduce il disco (divide il numero dei cilindri
per un certo numero e moltiplica il numero di testine per lo stesso);
2. creazione (e questo forse è meglio) di una partizione di avvio entro il 1024-esimo cilindro,
ad esempio ‘/boot/’ per GNU/Linux, senza abilitare la modalità LBA.
C’è da dire in ogni caso che le ultime versioni di LILO non presentano più queste limitazioni.
Basta quindi procurarsi una versione aggiornata di LILO.
388.1.6) Perché dopo avere spostato il disco con MS-Windows e dopo averlo collocato
come primario slave, MS-Windows non parte più? Ho aggiornato le impostazioni di LILO
ma riesco ad avviare solamente GNU/Linux.
Soluzione 1: BIOS
Dal BIOS si disabilita il disco fisso primario master, si salvano le impostazioni e si riavvia.
In questo modo MS-Windows si trova effettivamente sul primo disco fisso in fase di avvio
e così parte normalmente.
4
questione risolta con le recenti versioni di LILO
4435
Se non dovesse partire vuol dire che si è compromesso il MBR (Master Boot Record),
quindi si deve avviare con il disco di ripristino di MS-Windows, digitando il comando
seguente per rimettere a posto il MBR:
# fdisk /MBR[ Invio ]
Al termine si riavvia da disco fisso e MS-Windows dovrebbe partire regolarmente.
Soluzione 2: LILO
Nella sezione relativa a MS-Windows si aggiungono le seguenti impostazioni:
other = /dev/hdb1
label = DOS
table = /dev/hdb
#
#
#
#
#nel mio caso
le quattro righe seguenti indicano a LILO di far credere che
i dischi fissi siano invertiti, cioè
che lo slave primario sia sul
master primario e viceversa
map-drive=0x80
to = 0x81
map-drive=0x81
to = 0x80
In questo modo i dischi vengono rimappati istantaneamente al contrario rispetto a come
sono impostati.
Altro problema è cercare di installare MS-Windows su disco slave mentre sul master c’è già
GNU/Linux. Per farlo, occorre prima copiare il kernel su un dischetto, in modo da poter
eventualmente riavviare da floppy. Il comando necessario è:
# cat /boot/vmlinuz > /dev/fd0 [ Invio ]
dove ‘/boot/vmlinuz’ è il percorso assoluto per raggiungere l’immagine del kernel in uso
(basta provare ad avviare con il dischetto appena creato per verificare che il procedimento vada
a buon fine). Successivamente si procede con i passi seguenti:
1. da BIOS si deve disabilitare il disco master;
2. si lancia il setup di MS-Windows (avvio direttamente da CD-ROM, oppure avvio da
dischetto e poi installazione da CD-ROM);
3. si attende che MS-Windows concluda i suoi numerosi riavvii per terminare l’installazione;
4. si riavvia, rientrando nel BIOS e riabilitando il primo disco fisso;
5. si riavvia da dischetto con il dischetto contenente l’immagine del kernel creato prima di
iniziare;
6. da GNU/Linux, si modifica ‘/etc/lilo.conf’ nel modo indicato in precedenza;
7. si lancia ‘lilo’.
In questo modo, avviando la macchina con LILO si dovrebbe riuscire a caricare entrambi i sistemi
operativi.
4436
388.1.7) Come si fa a esportare il CD-ROM durante l’installazione via NFS?
Si deve aggiungere il percorso al file ‘/etc/exports’ facendo riferimento alle pagine di
manuale di nfs(5) e di exports(5).
/cdrom
host_che_mi_pare (ro)
Nel modello si vede la parola chiave ‘ro’, che sta per read only. Successivamente si fa ripartire
l’NFS con il comando seguente:
# /etc/init.d/nfs restart[ Invio ]
Ovviamente bisogna avere installato il demone ‘nfsd’, oppure bisogna avere compilato il
supporto per il server NFS nel kernel (c’è nei kernel 2.2, ma non è ancora del tutto stabile).
388.2 Avvio e arresto del sistema
388.2.1) Come si arresta il sistema? Come si riavvia?
Per arrestare il sistema si deve dare il comando:
# shutdown -h now[ Invio ]
Oppure:
# init 0[ Invio ]
Per riavviare il sistema il comando è:
# shutdown -r now[ Invio ]
Oppure:
# init 6[ Invio ]
388.2.2) Come si disabilita il supporto per l’APM in fase di avvio?
Al prompt di LILO occorre digitare:
LILO boot: linux apm=off[ Invio ]5
388.2.3) È possibile fermare l’arresto o il riavvio del sistema dopo averne dato il
comando?
Per poter farlo, occorre impartire il comando:
# shutdown -c [ Invio ]6
ma questa operazione di annullamento avrebbe successo esclusivamente qualora il comando
‘shutdown’ fosse stato impartito mediante l’indicazione esatta del tempo di esecuzione dello
stesso:
5
in questo caso linux è il nome dell’etichetta da inserire per invocare l’immagine del kernel e che è presente nel file
‘/etc/lilo.conf’
6
-c: cancel shutdown
4437
# shutdown -r ore:minuti &[ Invio ]
Nel caso in cui invece il comando venisse assegnato così:
le console virtuali e i terminali grafici verrebbero repentinamente disattivati impedendo qualsiasi
tipo di operazione.
388.2.4) Esiste un modo per rendere più repentino l’arresto del sistema?
Utilizzare ‘shutdown’ con l’opzione -n , comporta un riavvio e un arresto del sistema velocissimi. In ogni caso se ne sconsiglia decisamente l’uso come indicato anche nella pagina di
manuale:
man shutdown
-n
[DEPRECATED] Don’t call init(8) to do
the shutdown but do it ourself. The use of this
option is dis-couraged, and its results are not
always what you’d expect.
-n
[SCONSIGLIATO] Non impartite init(8) per lo
shutdown ma fatelo voi. L’utilizzo di questa opzione
è sconsigliato, e i risultati ottenuti
non sono quelli che ci si aspetterebbero.
388.2.5) Come si concede a tutti gli utenti la possibilità di arrestare il sistema?
Occorre attivare il bit SUID abbinando la proprietà all’utente ‘root’ (SUID-root), per
l’eseguibile ‘shutdown’:
# chmod 4755 /sbin/shutdown [ Invio ]
In questo modo ‘shutdown’ verrà sempre eseguito come se fosse l’utente ‘root’ a lanciarlo.
Un altro modo per ottenere lo stesso obiettivo è quello di creare un utente speciale ‘halt’. Ecco una porzione del file ‘/etc/passwd’ che indica quali dovrebbero essere le impostazioni di
questo ipotetico utente:
[...]
halt:x:0:0:,,,:/home/halt:/sbin/halt
[...]
In questa maniera l’arresto del sistema è consentito solo a coloro che hanno la password di
quell’utente.
388.2.6) Come si concede a tutti gli utenti la possibilità di riavviare il sistema?
Tale operazione può essere effettuata in diversi modi; in questo caso verrà spiegato come farlo
mediante il comando ‘sudo’.
Innanzitutto occorre modificare il file ‘/etc/sudoers’ mediante ‘visudo’:
# visudo[ Invio ]7
e aggiungere una riga tipo questa:
7
‘visudo’ è il ‘vi’ per ‘sudo’
4438
tizio
sempronio=/sbin/shutdown -[hr] now
In questo caso ‘tizio’ è l’utente e ‘sempronio’ il nome della macchina; ‘-[h|r]’ indica che
l’utente avrà la possibilità di arrestare e di riavviare il sistema.
Una volta apportate le modifiche, per arrestare il sistema o per riavviarlo, l’utente ‘tizio’ dovrà
impartire:
$ sudo shutdown -h now [ Invio ]
oppure:
$ sudo shutdown -r now [ Invio ]
A questo punto egli dovrà inserire la password per proseguire con l’arresto o il riavvio del
sistema.
388.2.7) Come si può impedire agli utenti del sistema di impartire il riavvio mediante la
combinazione di tasti [ Ctrl+Alt+Canc ]?
Occorre commentare la riga contenente ‘ctrlaltcanc’ nel file ‘/etc/inittab’.
388.2.8) Come funziona ‘install-mbr’ in una distribuzione GNU/Linux Debian?
In Debian GNU/Linux, ‘install-mbr’ aggiunge al MBR (Master Boot Record) un piccolo ma
potente codice per scegliere la partizione di avvio. In realtà questo evita anche di utilizzare il
MBR Dos che non è libero.
‘install-mbr’ si installa con il seguente comando:
# cd /usr/sbin[ Invio ]
# ./install-mbr /dev/hda[ Invio ]8
Una volta installato, dal riavvio successivo del sistema, se non si preme alcun tasto, l’MBR
modificato, invocherà il primo settore della prima partizione del primo disco fisso. Se invece si
premerà qualche tasto, ‘install-mbr’ visualizzerà il suo prompt. Quest’ultimo è costituito da
lettere e numeri.
Ecco un esempio di prompt:
14FA:
•
[1]
permette l’avvio della prima partizione;
•
[4]
permette l’avvio della quarta partizione;
•
[F]
permette l’avvio da dischetto;
8
install-mbr si installa al posto del MBR del primo disco fisso della catena IDE-EIDE. Indicando ‘/dev/sda’, si
installerà nel primo disco SCSI.
•
4439
[A]
opzioni avanzate.
Ulteriori informazioni possono essere rilevate nel file ‘/usr/doc/mbr/README’ di una
distribuzione Debian GNU/Linux.
388.2.9) Come è possibile avviare un sistema GNU/Linux da un sistema
Dos/MS-Windows?
Occorre utilizzare il comando ‘LOADLIN.EXE’. Prima di invocarlo però, occorre apportare qualche modifica al sistema Dos o MS-Windows. Bisogna infatti copiare ‘LOADLIN.EXE’ e le immagini del kernel all’interno di una directory dell’unità da cui si intende avviare il sistema
GNU/Linux.
Per invocare ‘LOADLIN.EXE’, supponendo di avere posto lo stesso comando e le immagini del
kernel nella directory ‘C:\LINUX\’, abbiamo a disposizione diverse metodiche:
1. si può inserire la riga:
INSTALL=C:\LINUX\LOADLIN.EXE
nel file ‘C:\CONFIG.SYS’;
2. si può inserire il comando ‘LOADLIN.EXE’ nel file ‘C:\AUTOEXEC.BAT’;
3. infine si può ricorrere a script (batch).
Esempi di script:
rem C:\LINUX\LINUX2.BAT
rem l’immagine è quella del kernel 2.2.2 e
rem la partizione è la seconda di un disco SCSI
@pause
@echo Premere Ctrl-C per interrompere
C:\LINUX\LOADLIN C:\LINUX\bzImage.222 root=/dev/sda2 ro
rem C:\LINUX\LINUX_R.BAT
rem l’immagine è quella del kernel 2.0.36 della Red Hat
rem la partizione è la seconda di un disco IDE/EIDE master
@pause
C:\LINUX\LOADLIN C:\LINUX\vmlinuz2.036 root=/dev/hda2 ro
rem C:\LINUX\SINGLE.BAT
rem l’immagine è quella del kernel 2.0.36 della Red Hat
rem la partizione è la seconda di un disco IDE/EIDE slave
@pause
C:\LINUX\LOADLIN C:\LINUX\vmlinuz2.036 single root=/dev/hdb2 ro
Notiamo in quest’ultimo esempio l’opzione single che permette di avviare il sistema in modalità
utente singolo.
4440
388.2.10) Come si avvia GNU/Linux dal Boot Manager di MS-Windows NT?
Occorre innanzitutto installare LILO sulla partizione Linux. Va poi generato il file
‘bootsect.lin’ contenente l’immagine del settore di avvio della partizione Linux:
# dd if=/dev/hdx of= /tmp/bootsect.lin bs=512 count=1[ Invio ]9
‘bootsect.lin’ va poi copiato nella partizione di avvio di MS-Windows NT e va modificato il
file ‘boot.ini’ di MS-Windows NT come segue:
[boot loader]
timeout=5
default=multi(0)disk(0)rdisk(0)partition(1)\WINNT
[operating systems]
multi(0)disk(0)rdisk(0)partition(1)\WINNT="Windows NT Server Version 4.00"
multi(0)disk(0)rdisk(0)partition(1)\WINNT="Windows NT Server Version 4.00 [VGA mode]" /basevideo /s
C:\="MS-DOS"
c:\bootsect.lin="Linux"
Occorre infine ricordare che ogni modifica di LILO, comporta il fatto che si deve ricreare il file
immagine e che si deve copiarlo nuovamente nella partizione di MS-Windows NT.
388.2.11) Ho impostato involontariamente il livello di esecuzione (runlevel ) a zero e il
sistema inizia la procedura di arresto non appena ha terminato l’avvio. Che posso fare?
Al prompt di LILO occorre dare il comando:
LILO boot: linux init=/bin/bash [ Invio ]
Si intende che ‘linux’ deve essere sostituito con l’etichetta di LILO deputata al caricamento di
GNU/Linux
Una volta ottenuto l’accesso al sistema si deve montare a mano in modalità lettura-scrittura il
file system radice (root):
bash-2.03$ mount -n -o remount,rw /[ Invio ]
Questo permette di apportare le modifiche necessarie per tornare al livello di esecuzione preferito.
Un’altra soluzione consiste nell’impartire ‘linux 1’ sempre al prompt di LILO e cambiare poi
repentinamente livello di esecuzione.
388.2.12) Come è possibile fare spegnere la macchina alla fine del processo di arresto?
Se la macchina in questione ha la capacità di gestire autonomamente l’alimentazione (APM),
è necessario ricompilare il kernel includendo il supporto per l’APM selezionando l’opzione
‘power off on shutdown’. Dopo questa modifica la macchina dovrebbe spegnersi dopo le
procedure d’arresto (shutdown). Se così non fosse, occorre verificare che nel file ‘/etc/init.d/
halt’ (o in ‘/etc/rc.d/init.d/halt’) sia presente l’opzione -p del comando ‘halt’.
Ecco un esempio del file ‘halt’:
#! /bin/sh
#
# halt
9
Execute the halt command.
x è la lettera della partizione Linux
#
# Version:
#
@(#)halt
4441
2.75
19-May-1998
[email protected]
PATH=/sbin:/bin:/usr/sbin:/usr/bin
# See if we need to cut the power.
if [ -x /etc/init.d/ups-monitor ]
then
/etc/init.d/ups-monitor poweroff
fi
halt -d -f -i -p
388.2.13) Come è possibile far spegnere la macchina se si dispone di una scheda madre
‘Soyo 5-EM’ o ‘Soyo 5 ema’?
Occorre collegarsi al sito della Soyo (<http://www.soyo.com>) spostandosi nella sezione
‘software’. Qui troviamo una directory chiamata ‘patch/’ contenente due file di differenze
(patch) per le due schede in oggetto. È necessario ora applicare i file di differenze al kernel che
dovrà essere ricompilato includendo il supporto per l’APM selezionando l’opzione ‘power off
on shutdown’. 10 .
388.2.14) È possibile avviare la procedura di arresto del sistema con una combinazione di
tasti?
Nel file ‘/etc/inittab’ troviamo la seguente sezione:
# Trap CTRL-ALT-DELETE
ca::ctrlaltdel:/sbin/shutdown -t3 -r now
Se sostituiamo -r con -h , alla pressione contemporanea di
la procedura di arresto.
[ Ctrl+Alt+Canc ]
il sistema comincerà
388.2.15) Perché in alcune distribuzioni tutti gli utenti hanno la facoltà di impartire il
comando ‘halt’?
Per evitare che gli utenti possano impartire i comandi ‘halt’ e ‘shutdown’, è sufficiente creare il
file ‘/etc/halt.users’ e aggiungere due righe ai file ‘/etc/pam.d/halt’ e ‘/etc/pam.d/
shutdown’ in modo che risultino così:
#%PAM-1.0
auth
auth
auth
auth
account
sufficient
requisite
onerr=3Dfail
required
required
required
/lib/security/pam_rootok.so
/lib/security/pam_listfile.so \
sense=allow item=user file=/etc/halt.users
/lib/security/pam_console.so
/lib/security/pam_pwdb.so
/lib/security/pam_permit.so
In questa maniera solo gli utenti menzionati in ‘/etc/halt.users’ possono utilizzare ‘halt’
e ‘shutdown’. Ovviamente il controllo della password per l’utente rimane, per essere sicuri che
sia proprio l’utente che sta digitando colui che ha impartito il comando.
10
La documentazione allegata ai file di differenze (patch) indica la versione minima del kernel che occorre utilizzare
per poterli applicare
4442
388.2.16) Come è possibile visualizzare messaggi o loghi all’avvio di GNU/Linux?
Le metodiche da utilizzare per ottenere questo risultato variano al variare del momento in cui si
vuole che il messaggio o il logo venga visualizzato.
Se ad esempio vogliamo fare visualizzare al sistema un messaggio al prompt di LILO, occorre
mettere nel file ‘/etc/lilo.conf’ la riga:
message= <var>/percorso/nomefile</var>
Per rendere effettive le modifiche occorrerà dare il comando:
# lilo[ Invio ]
Per ottenere questo messaggio colorato, è necessario installare Lilo-Colors che altro non è che un
file di differenze per LILO. Si tenga presente che esiste un altro programma chiamato BootLogo
che è un generatore di messaggi sia per la versione monocromatica che per la versione colorata
di LILO.
Per avere un logo ANSI o ASCII al login di GNU/Linux possiamo utilizzare Linux Logo. Simile
è Welcome2L.
Figura 388.1. Linux Logo.
Figura 388.2. Linux Logo in visualizzazione banner.
4443
Figura 388.3. Welcome2L.
Inoltre, se ricompilando il kernel si include il supporto per ‘fbcon’, si avrà la possibilità di fare
apparire durante l’avvio del sistema un pinguino in modalità grafica.
388.2.17) KERNEL PANIC: VFS: Unable to mount root fs on 03:03
Questo tipo di errore si presenta quando il sistema non riesce a montare la radice del file system.
Probabilmente c’è stato un cambiamento di disposizione dei dischi fissi (aggiunta, rimozione o
inversione).
Per risolvere il problema, occorre far ripartire il sistema mediante un disco di avvio. Al prompt
di LILO si deve indicare quale è la radice del file system:
LILO boot: linux 1 root=/dev/hdx [ Invio ]11
Una volta ottenuto l’accesso al sistema occorre modificare il file ‘/etc/fstab’ indicando il
dispositivo corretto della partizione che costituisce la partizione principale. La stessa modifica
va effettuata anche nel file ‘/etc/lilo.conf’ e per rendere effettive le modifiche va rilanciato
‘lilo’:
# /sbin/lilo[ Invio ]
388.2.18) Perché dopo la ricompilazione del kernel viene visualizzato un messaggio di
kernel panic ?
Quando si ricompila il kernel, è possibile gestirne alcune parti in forma di modulo. Ciò che non
deve assolutamente essere caricato sotto forma di modulo è ciò che è necessario in fase di avvio.
Infatti, se il modulo per i dischi IDE/EIDE viene caricato sotto forma di modulo, il sistema non
sarà in grado di avviarsi e produrrà un messaggio di ‘kernel panic’; questo potrebbe spiegare
il problema.
11
x va sostituito con il dispositivo che identifica la partizione contenente la radice del file system. Bisogna ricordare
però che si dovrà indicare il dispositivo corrente della partizione e non quello che sussisteva prima dell’errore.
4444
388.2.19)
swapon: warning: /dev/hda1 has insecure permissions 0660, 0600 suggested
Con questo messaggio il sistema ci avverte di una condizione di scarsa sicurezza relativa ai permessi di una partizione; in questo caso si tratta della prima partizione dell’unità IDE/EIDE master
primaria che possiede inutilmente i permessi di lettura e scrittura per il gruppo del proprietario.
Mediante il comando:
# chmod 0600 /dev/hda1[ Invio ]
si ristabiliscono i permessi corretti.
388.2.20)
Parallelizing fsck version x.yy /dev/hdxy: UNEXPECTED INCONSISTENCY; RUN fsck MANUALLY
Questo tipo di messaggio appare prevalentemente quando il sistema non è stato arrestato in
maniera corretta. Per risolvere il problema occorre dare il seguente comando:
# e2fsck /dev/hdxy[ Invio ]
Occorre rispondere affermativamente alle eventuali richieste di clonazione di inode.
388.3 Tipi di file system e partizioni
388.3.1) Come si fa a indicare che alcune directory del file system sono distribuite su
dispositivi differenti?
Per fare questa operazione occorre aggiungere nel file ‘/etc/fstab’ una riga per ogni
dispositivo o file system remoto che si voglia montare.
Ogni riga di ‘/etc/fstab’ è composta da 6 campi:
1. dispositivo o file system remoto;
2. directory di innesto (mount point) del file system;
3. tipo del file system:
• ext2;
• vfat;
• nfs;
• swap;
• iso9660;
• ecc.
4. opzioni di montaggio(‘user’, ‘auto’, ‘noauto’, ecc.)
5. campo usato da ‘dump’
4445
6. campo usato da ‘fsck’
Se si vuole ad esempio che venga innestata al file system principale la directory ‘/var/’ che
risiede sulla terza partizione del secondo disco fisso, bisogna aggiungere la seguente riga al file
‘/etc/fstab’:
/dev/hdb3
/var
ext2
defaults
1 2
388.3.2) Come si visualizza la struttura del file system?
Per vedere quali partizioni sono innestate al file system principale, è sufficiente impartire il
comando ‘df’:
# df[ Invio ]
Figura 388.4. La visualizzazione della struttura del file system.
Per visualizzare invece il partizionamento di un’unità, si darà il comando:
# fdisk -l dispositivo [ Invio ]12
388.3.3) Come si crea un file system Ext2 nella terza partizione del secondo disco fisso
IDE/EIDE?
Assumendo che il partizionamento sia un’operazione già effettuata, il comando sarà:
# mke2fs /dev/hdb3[ Invio ]
Per controllare i blocchi difettosi ed eventualmente fissarli, si utilizza l’opzione ‘-c’ di ‘mke2fs’:
# mke2fs -c /dev/hdb3[ Invio ]
388.3.4) Come si verifica se ci sono settori danneggiati su partizioni con file system Ext2?
Occorre impartire il comando:
# fsck.ext2 -c /dev/partizione [ Invio ]13
Oppure:
# e2fsck -c partizione [ Invio ]
12
dove dispositivo è l’unità da analizzare.
partizione è il nome del dispositivo corrispondente alla partizione da controllare. L’opzione -c consente di verificare
la presenza di settori danneggiati.
13
4446
388.3.5) Come si possono ridimensionare le partizioni con file system Ext2?
Per tale scopo esistono due strumenti molto validi:
1. GNU parted; 14
2. ext2resize; 15
388.3.6) Come si può creare da GNU/Linux un file system Dos-FAT?
Il comando ‘mkdosfs’ o il comando ‘mkfs.msdos’ sono preposti a questo scopo. Ecco un esempio che mostra come creare un file system Dos-FAT nella terza partizione del secondo disco SCSI
(‘/dev/sdb3’) dopo avere verificato la presenza di settori difettosi (-n ):
# mkdosfs -c /dev/sdb3[ Invio ]
388.3.7) Come si verifica la presenza di settori danneggiati in una partizione contenente
un file system Dos-FAT?
Con il comando ‘fsck.msdos’:
# fsck.msdos -r /dev/hda1[ Invio ]
In questo caso sarà la prima partizione del primo disco fisso IDE/EIDE ad essere controllata e
nel caso venisse trovata qualche irregolarità, verrebbe chiesto all’utente come comportarsi.
388.4 Swap
388.4.1) Se si avesse bisogno di ulteriore spazio ‘swap’, come si aggiunge?
Si può creare una partizione Linux-swap oppure un file-swap.
La partizione da rendere partizione Linux-swap si crea come tutte le altre partizioni; il file invece
deve essere creato nel seguente modo:
# dd if=/dev/zero of=/file_swap bs=1024 count=1024[ Invio ]16
Per rendere ‘swap’ la partizione ‘/dev/hda2’, si darà il comando:
# mkswap -c /dev/hda2[ Invio ]17
Per rendere invece ‘swap’ il file ‘file_swap’, si darà il comando:
# mkswap /file_swap 1024[ Invio ]
Sono stati quindi predisposti due spazi ‘swap’ che però non sono ancora utilizzati. Per farlo,
occorre impartire il comando ‘swapon’:
14
GNU parted GPL
ext2resize GPL
16
Si deve creare uno spazio di dimensioni multiple di 4; in questo caso si sta creando un file di circa 1 Mibyte.
17
L’opzione -c sta ad indicare che verrà effettuato un controllo per i settori difettosi. Questa opzione non deve essere
utilizzata nella creazione di uno spazio ‘swap’ su un file.
15
4447
# swapon /dev/hda1[ Invio ]
Oppure, nel caso del file:
# swapon file_swap[ Invio ]
Se non si vuole lanciare ogni volta questo comando, basta inserire nel file ‘/etc/fstab’ le
indicazioni del nuovo spazio di ‘swap’ ed esso verrà attivato ad ogni avvio del sistema. Ecco una
porzione d’esempio del file ‘/etc/fstab’.
[...]
/file_swap
[...]
none
swap
sw
0 0
388.5 Montare i dischi
388.5.1) Operazioni con un dischetto Dos (file system vfat)
Come si crea in Linux un dischetto capace di ospitare file generati con un sistema operativo Dos?
Occorre innanzitutto preparare il dischetto mediante la formattazione:
# fdformat /dev/fd0[ Invio ]
Il dischetto appena formattato non ha ancora una struttura; bisogna infatti crearci un file system
adatto. Nel nostro caso si può utilizzare l’opzione ‘vfat’ o ‘msdos’.
# mkfs -t msdos /dev/fd0[ Invio ]
Ora che il dischetto possiede un file system, per operarvi, occorre innestarlo al file system principale in uno dei suoi punti di montaggio. Se il punto di montaggio risulta essere ‘/mnt/floppy’,
il comando per la procedura di innesto sarà:
# mount /dev/fd0 /mnt/floppy[ Invio ]
Si procede quindi con l’operazione di copia:
# cp file.txt /mnt/floppy[ Invio ]
Infine si distacca il file system del dischetto da quello principale:
# umount /mnt/floppy[ Invio ]
388.5.2) Non riesco a montare dischetti con file system Ext2; se uso dischetti con
file system Dos invece non ho problemi, perché?
Questo generalmente si verifica quando si cerca di innestare (montare) il file system di un dispositivo mediante il comando ‘mount’ specificando solamente il nome del dispositivo contenente il
file system da innestare o solamente il punto di montaggio. In tale maniera vengono richiamate
le impostazioni riposte nel file ‘/etc/fstab’.
Nel file suddetto, nella riga riguardante ‘/dev/fd0’, in corrispondenza del campo in cui viene
indicato il file system del dispositivo, sarà presente la voce ‘msdos’ o ‘vfat’.
4448
Occorre sostituirla con la voce ‘ext2’ o qualora si desideri continuare a mantenere tale impostazione in ‘/etc/fstab’ occorre procedere al montaggio del file system del dischetto
manualmente, indicando tutte le opzioni necessarie:
# mount -t ext2 /dev/fd0 /mnt/floppy[ Invio ]18
Un’altra soluzione consiste nell’inserire un’altra riga nel file ‘/etc/fstab’ contenente le indicazioni di montaggio dello stesso dispositivo contenente però un file system diverso (in questo
caso ‘ext2’) da innestare su un altro punto di montaggio.
388.5.3) Come si può montare una partizione con file system NTFS (MS-Windows NT)?
Occorre ricompilare il kernel includendo l’opzione NTFS filesystem support (read only) per
accedere alla partizione di MS-Windows NT.
Il seguente comando permette di montare la partizione:
# mount -t NTFS /dev/hdx /y [ Invio ]19
388.5.4) Come si monta una partizione contenente MS-Windows 2000?
Il file system di MS-Windows 2000 può essere di due tipi:
• NTFS;
• FAT32.
Nel primo caso, l’immagine del kernel che si utilizza deve contenere il supporto per il file system
NTFS (questo supporto può essere compilato all’interno dell’immagine oppure può essere caricato mediante il modulo apposito). Una volta abilitato questo supporto, il comando per effettuare
il montaggio è:
# mount -t ntfs /dev/x /y [ Invio ]20
Nel secondo invece, se la partizione di MS-Windows 2000 presenta un file system FAT32, allora
il comando sarà il seguente:
# mount -t ntfs /dev/x /y [ Invio ]21
388.5.5) Come si fa a dare agli utenti il permesso di montare il lettore dischetti e il lettore
CD-ROM?
Occorre modificare il file ‘/etc/fstab’ inserendo nel terzultimo campo dei dispositivi ‘/dev/
fd0’ e ‘/dev/cdrom’ quanto segue:
users,noauto
18
19
‘/mnt/floppy’ è in questo caso il punto di montaggio desiderato.
dove x rappresenta la partizione contenente il file system NTFS e y il punto di montaggio (es. ‘/mnt/nt’).
x rappresenta la partizione contenente il file system NTFS di MS-Windows 2000 e y il punto di montaggio (es.
‘/mnt/win2k’).
21
Valgono le indicazioni del comando precedente.
20
4449
Ecco un estratto di un ‘/etc/fstab’ che contiene tale configurazione:
# cat /etc/fstab [ Invio ]
# /etc/fstab: static file system information.
#
# <file system> <mount point>
<type> <options>
/dev/hda2
/
ext2
defaults,errors=remount-ro
/dev/hda3
none
swap
sw
proc
/proc
proc
defaults
/dev/fd0
/floppy
auto
users,noauto
/dev/cdrom
/cdrom
iso9660 users,noauto
/dev/hdb7
/mnt/debian2.1 ext2
defaults,user,auto
/dev/hda1
/mnt/win95
vfat
defaults,user,auto
<dump> <pass>
0
1
0
0
0
0
0
0
0
0
0
0
0
0
388.5.6) Ma cosa cambia se si mette ‘user’ o ‘users’ nei campi di ‘/etc/fstab’?
La risposta la troviamo nelle pagine di manuale di ‘mount’ (mount(8)):
[...]
For more details, see fstab(5).
Only the user that
mounted a filesystem can unmount it again. If any user
should be able to unmount, then use users instead of user
in the fstab line.
[...]
[...]
Per ulteriori dettagli, controllate fstab(5).
Solamente
l’utente che ha montato un file system può smontarlo.
tutti gli utenti dovessero avere la possibilità di smontarlo,
allora utilizzate users al posto di user nella riga del file
fstab.
[...]
Se
388.5.7) Come si concedono tutti i permessi di una partizione ad ogni utente del sistema?
Occorre indicare nel file ‘/etc/fstab’ le opzioni ‘user’, ‘quiet’ ed ‘umask’:
/dev/hda1
/mnt/msdos
vfat
quiet,umask=000 0
0
da mount(8):
user
Permette ad un utente normale di montare il
file system. Questa opzione implica anche le
opzioni noexec, nosuid, e nodev (finché ciò
non sia cambiato dal superuser usando, ad
esempio, la seguente riga
di
opzioni:
user,exec,dev,suid).
quiet
Abilita il flag quiet. Tentativi di chown o chmod
su file non restituiscono errori, sebbene falliscano. Usare con cautela!
umask=valore
Imposta l’umask (la bitmask dei permessi che non
sono presenti). Il default è l’umask del processo
corrente. Il valore va dato in ottale.
4450
388.5.8) No final new line in /etc/fstab
Questo messaggio viene visualizzato quando manca un <CR> alla fine dell’ultima riga del file ‘/etc/fstab’. Occorre aprire il file per la modifica, posizionarsi alla fine dell’ultima riga,
premere [ Invio ] e salvare.
388.5.9) Come si fa a montare automaticamente i dischi all’avvio?
Il file ‘/etc/fstab’ è un file di configurazione composto da righe. Ogni riga, oltre ad indicare
quale dispositivo deve essere montato, dove deve essere agganciato al file system principale, di
che tipo è (‘vfat’, ‘ext2’, ‘iso9660’, ‘ntfs’, ecc.), presenta altre opzioni. Tra queste abbiamo
l’opzione ‘auto’. Le righe che presentano tale opzione consentono al dispositivo in questione
di venire montato automaticamente all’avvio del sistema, senza bisogno di alcun tipo di comando. Le partizioni che non devono essere montate automaticamente, presentano invece l’opzione
‘noauto’ (il CD-ROM ad esempio) che è una delle opzioni comprese in ‘default’.
Inoltre, se un dispositivo è elencato in ‘/etc/fstab’ ma non presenta l’opzione ‘auto’, sarà
sufficiente impartire il comando:
# mount dispositivo [ Invio ]
oppure:
# mount /punto_di_montaggio [ Invio ]
per montare il dispositivo in questione, e sarà l’eseguibile ‘mount’ a rilevare le opzioni necessarie
dal file ‘/etc/fstab’.
388.5.10) Come è possibile montare le partizioni Dos/MS-Windows 9x (file system vfat)?
Per montare le partizioni Dos/MS-Windows 9x occorre disporre di un’immagine del kernel che
contenga il supporto per file system vfat.
Una volta ricompilato il kernel, o se si disponesse già di un’immagine con tale supporto, per
montare le partizioni Dos/MS-Windows occorrerà indicare ‘vfat’ come tipo di file system:
# mount -t vfat /dispositivo / punto_di_montaggio [ Invio ]
388.5.11) Effettuando il login da un’altra console, si ottengono a volte numerosi messaggi
relativi a dispositivi già montati. Come si possono eliminare?
Si può evitare questo fenomeno indirizzando lo standard error su ‘/dev/null’. Il comando per
montare i dispositivi in questione, risulterà così:
# mount /dispositivo /punto_di_montaggio 2>/dev/null[ Invio ]
‘2>’ è appunto il comando di reindirizzamento dello standard error.
Generalmente questo accade solo se il dispositivo o i dispositivi in questione, vengono montati
a mano. Montare i dischi di frequente utilizzo mediante il file ‘/etc/fstab’ risulta essere la
modalità più corretta.
4451
388.5.12) Come è possibile accedere a partizioni GNU/Linux (file system Ext2) da
MS-Windows?
Si possono usare ext2 tools 22 FSDEXT2 23 Explore2fs 24 .
I pacchetti possono essere prelevati rispettivamente presso <ftp://ftp.pg.gda.pl/pub/linux/util/
e <http://uranus.it.swin.edu.au/~jn/linux/explore2fs.htm>.
fsdext2.zip>
Il primo è molto sicuro e si utilizza da riga di comando, il secondo permette di montare partizioni
Ext2 come se fossero dischi Dos, solo che è molto pericoloso perché molte volte blocca i canali
dell’interfaccia IDE/EIDE.
388.6 LILO
388.6.1) Installazione e configurazione di LILO
Il file di configurazione di LILO 25 è ‘/etc/lilo.conf’. Segue un esempio di ‘/etc/
lilo.conf’ di un sistema che presenta due dischi fissi, il primo contenente MS-Windows ed il
secondo contenente GNU/Linux. LILO verrà installato sul primo disco e farà partire in maniera
predefinita MS-Windows dal momento che è il primo dei due sistemi operativi indicati.
boot=/dev/hda
map=/boot/map
prompt
timeout=50
other=/dev/hda1
\011label=dos
\011table=/dev/hda
image=/boot/vmlinuz-2.2.5-15
\011label=linux
\011root=/dev/hdb1
\011read-only
Al prompt di LILO si avranno a disposizione 5 secondi (timeout = 50) per scegliere il sistema da
avviare. Per avviare GNU/Linux occorrerà inserire ‘linux’ come dichiarato nella variabile label
del secondo sistema operativo.
Si deve ricordare che non basta modificare il file ‘/etc/lilo.conf’ per rendere effettive le
modifiche. Occorrerà invece lanciare l’eseguibile ‘lilo’:
# lilo -v[ Invio ]26
388.6.2) Come posso avviare Linux con un dischetto di avvio, in maniera veloce?
I dischetti di avvio generalmente contengono, oltre al gestore degli avvii (boot loader), anche
l’immagine del kernel per cui l’operazione di caricamento del sistema risulta molto lenta. Si
può in ogni caso accelerare tale procedura mantenendo solo il gestore degli avvii (boot loader)
su dischetto, ad esempio LILO, e utilizzando un’immagine del kernel presente sul file system
principale.
Per fare questo occorre modificare il file ‘/etc/lilo.conf’ che dovrà risultare simile a questo:
22
ext2 tools GPL
FSDEXT2 GPL
24
Explore2fs GPL
25
LILO licenza speciale senza vincoli particolari
26
‘-v’ mostra alcuni messaggi sullo stato del processo.
23
4452
boot=/dev/fd0
vga=3
compact
read-only
prompt
timeout=0
(l’avvio avverrà da dischetto)
image = /vmlinuz
(indica il percorso dell’ immagine del kernel)
root = /dev/hdb2
(indica la partizione che sarà il file
system principale in questo caso è la
seconda partizione del secondo disco della
prima catena IDE/EIDE)
(l’avvio avverrà immediatamente
dopo l’accesso al dischetto)
label = linux
Occorre a questo punto inserire un dischetto formattato nel lettore dei dischetti, e lanciare:
# lilo -v[ Invio ]
Al termine si riavvia il sistema assicurandosi di avere riabilitato nel BIOS l’avvio da dischetto. Può capitare, anche se è molto raro, che il kernel non si avvii. In tal caso, dopo avere
verificato l’esattezza dei dati inseriti in ‘/etc/lilo.conf’, si può provare a eliminare la riga ‘compact’ perché su alcuni sistemi può non funzionare. Questo comporta solamente un
leggerissimo rallentamento della fase di avvio.
Il fatto di potere provare l’avvio del sistema da dischetto permette di provare in tutta sicurezza
i procedimenti di avvii multipli dei sistemi operativi. Capita spesso di avere delle difficoltà nel
configurare un sistema che debba poter avviare alternativamente Linux, MS-Windows 9x e MSWindows NT. Una volta soddisfatti delle configurazioni provate su dischetto, basterà sostituire
‘/dev/fd0’ con ‘/dev/hda’ e rilanciare:
# lilo -v[ Invio ]
388.6.3) Come si installa LILO in una posizione diversa da quella attuale?
Il file ‘/etc/lilo.conf’ contiene la riga:
boot=
Questa indica su quale dispositivo o su quale partizione dovrà essere installato LILO. Indicando
‘/dev/hda’ LILO verrà installato nel settore di avvio (boot) del primo disco fisso IDE/EIDE;
indicando invece ‘/dev/hdb2’, verrà installato nella seconda partizione del secondo disco fisso
della prima catena IDE/EIDE. In questo ultimo caso, la partizione deve essere resa avviabile
(mediante il comando ‘a’ di ‘fdisk’ o l’apposita casella di ‘cfdisk’).
Dopo aver fatto le modifiche, LILO deve essere rilanciato mediante il comando:
# lilo -v[ Invio ]
4453
388.6.4) Come si elimina LILO?
Da un sistema con sistema operativo Dos o MS-Windows:
C:\> fdisk /mbr[ Invio ]
oppure, dopo avere avviato da un disco di ripristino di MS-Windows:
C:\> sys c:[ Invio ]
Da Linux invece:
# lilo -U[ Invio ]
oppure si può utilizzare ‘dd’ per riscrivere il MBR originario grazie al file di backup che LILO
crea al momento della sua installazione. Questo file generalmente risiede in ‘/boot’ e ha di solito
un nome tipo ‘boot.xxxx’ (xxxx può assumere diversi valori). Il comando per riscrivere il MBR
è:
# dd if=boot.xxxxx of =/dev/hda bs=446 count=1[ Invio ]
388.6.5) Come si fa a scegliere quale sistema operativo avviare in maniera predefinita con
LILO?
Il sistema operativo che si avvia in maniera predefinita è il primo di quelli indicati nel file ‘/etc/
lilo.conf’. Se ad esempio si dispone di un ‘/etc/lilo.conf’ come il seguente, il sistema
operativo predefinito sarà GNU/Linux
boot=/dev/sdb1
map=/boot/map
prompt
timeout=50
image=/boot/vmlinuz
\011label=linux
\011root=/dev/sdb1
\011initrd=/boot/initrd
\011read-only
other=/dev/sda1
\011label=dos
\011table=/dev/sda
Se invece si ha l’intenzione di rendere MS-Windows il sistema predefinito, occorrerà
semplicemente invertire le sezioni ‘image’ e ‘other’:
boot=/dev/sdb1
map=/boot/map
prompt
timeout=50
other=/dev/sda1
\011label=dos
\011table=/dev/sda
image=/boot/vmlinuz
\011label=linux
\011root=/dev/sdb1
\011initrd=/boot/initrd
\011read-only
4454
Ogni cambiamento effettuato dovrà comunque essere sempre seguito dal comando ‘lilo’:
# lilo -v[ Invio ]
4455
388.6.6) Come è possibile con LILO gestire più distribuzioni GNU/Linux sullo stesso
sistema?
Assumendo che il ‘/etc/lilo.conf’ sia originariamente simile a questo:
boot=/dev/hda
map=/boot/map
prompt
timeout=50
image=/boot/bzImage
\011label=linux.debian
\011root=/dev/hda1
\011read-only
si deduce che LILO è per ora in grado di avviare una sola distribuzione. Per permettere a LILO
di avviare altre distribuzioni, sarà necessario aggiungere tante sezioni ‘image’ quante saranno le
ulteriori distribuzioni da avviare.
Ogni sezione ‘image’ indicherà il nome dell’immagine del kernel da avviare, il suo percorso, la
partizione su cui montare il file system principale (root).
Se si volesse quindi aggiungere una sezione che possa invocare una seconda distribuzione,
presente su ‘/dev/hda4’, si dovrà aggiungere il seguente codice:
label=linux.redhat
root=/dev/hda4
read-only
Questo presume che occorre copiare nella directory ‘/boot’ della prima distribuzione, l’immagine del kernel della seconda; la directory ‘/lib/modules/x’ 27 deve essere copiata nella directory ‘/lib/modules/’ della prima distribuzione. ‘linux.redhat’ sarà l’etichetta che servirà
ad invocare la seconda distribuzione.
Ecco quindi il ‘/etc/lilo.conf’ completo:
boot=/dev/hda
map=/boot/map
prompt
timeout=50
image=/boot/bzImage
label=linux.debian
root=/dev/hda1
read-only
label=linux.redhat
root=/dev/hda4
read-only
388.6.7) Come si deve configurare LILO se sulla macchina è installato anche
MS-Windows NT?
Assumendo che sul primo disco sia installato GNU/Linux e MS-Windows ad esempio sulle partizioni ‘/dev/hda1’ e ‘/dev/hda2’ e che MS-Windows NT sia installato sul disco fisso slave,
il file ‘/etc/lilo.conf’ dovrà essere configurato come nell’esempio seguente:
27
x è la versione del kernel della seconda distribuzione.
4456
boot=/dev/hda
map=/boot/map
prompt
timeout=30
other=/dev/hda1
label=dos
table=/dev/hda
label=linux
root=/dev/hda2
read-only
other=/dev/hdb
label=nt
map-drive=0x80
to = 0x81
map-drive=0x81
to = 0x80
LILO verrà quindi installato sul MBR del primo disco fisso. La configurazione ora descritta,
permetterà di scegliere al prompt di LILO uno dei tre sistemi operativi mediante le tre etichette:
1. dos
2. linux
3. nt
La scelta di uno dei primi due sistemi operativi comporterà il loro avvio in maniera convenzionale. La scelta invece di MS-Windows NT comporterà lo scambio logico dei codici dell’identificazione dei dischi. Essi sono tipicamente 8016 per il primo disco IDE master) e 8116 per il secondo
(slave). La porzione:
map-drive=0x80
to = 0x81
map-drive=0x81
to = 0x80
effettuerà questo scambio permettendo a MS-Windows NT di trovarsi su un disco master.
Considerando questa possibilità è bene provvedere, ad installare MS-Windows NT o su un disco
montato come master o su un disco slave dopo aver provveduto a disabilitare dal BIOS il disco
fisso master contenente gli altri sistemi operativi. Dopo l’installazione, si dovrà reimpostare come
slave il disco in oggetto.
388.6.8) Come si configura LILO se si vuole installare una distribuzione GNU/Linux sul
primo disco fisso e MS-Windows su un altro?
MS-Windows per avviarsi deve risiedere nel primo disco fisso della prima catena IDE/EIDE;
se questo non è possibile si deve ricorrere alle opzioni ‘map-drive’ di LILO. Mediante queste
opzioni, si effettuerà lo scambio logico dei codici dell’identificazione dei dischi. Essi sono 8016
per il disco master della prima catena IDE/EIDE e 8116 per il disco slave della stessa catena e
così via. Lo scambio permette di rendere master dischi slave e viceversa.
Con il ‘/etc/lilo.conf’ configurato in questo modo:
boot=/dev/hda
map=/boot/map
4457
default=linux
prompt
timeout=20
read-only
root=/dev/hda1
image=/vmlinuz
\011label=linux
other=/dev/hdb1
\011label=win
\011map-drive=0x80
\011to=0x81
\011map-drive=0x81
\011to=0x80
MS-Windows potrà essere avviato normalmente seppure esso non risieda nel primo disco fisso
della prima catena IDE/EIDE.
388.6.9) Se si reinstalla MS-Windows, il MBR contenente LILO verrà sovrascritto; come
posso prevenire questo problema?
Si consiglia in genere, prima di trovarsi in situazioni spiacevoli di replicare su dischetto il proprio
LILO una volta soddisfatti del suo funzionamento. Per fare questo, basta sostituire, all’interno
del file ‘/etc/lilo.conf’ queste righe:
boot=/dev/hda
map=/boot/map
con queste altre:
boot=/dev/fd0
compact
read-only
e rilanciare ‘lilo’ con un dischetto inserito nel lettore:
# lilo -v[ Invio ]
In tal modo, qualora il MBR (Master Boot Record) venisse sovrascritto, si sarà in grado di avviare
il sistema esattamente come prima ma da dischetto. A quel punto non resterà altro che rilanciare
‘lilo’ assicurandosi che le impostazioni di ‘boot’, ‘map’ e ‘install’ siano corrette.
388.6.10) Come si può impostare una password per LILO?
L’indicazione della password per LILO deve essere posta nel file ‘/etc/lilo.con’. La sintassi
è semplice ed è indicata dalla pagina di manuale di lilo.conf (1):
password=password
La password può essere inserita sia nella sezione con le impostazioni generali che nelle singole
sezioni specifiche di ogni sistema operativo.
4458
388.6.11) Perché digitare «linux 1» al prompt di LILO consente l’accesso al sistema senza
richiesta di password?
Tutto dipende dal fatto che per poter dare questo comando bisogna avere l’accesso fisico al sistema. Un server di solito, al contrario di macchine casalinghe, si trova in luoghi protetti il cui
accesso è riservato a poche persone. Riavviare un server è un operazione a volte possibile esclusivamente via hardware. Ecco quindi che la possibilità di dare un comando a LILO è una facoltà
riservata spesso solo a coloro che possono accedere fisicamente alla macchina. E’ possibile in
ogni caso impostare una password aggiungendo la riga:
password=password
al file ‘/etc/lilo.conf’; in questo modo anche se il sistema verrà riavviato, ci sarà un controllo
al prompt di LILO. Inoltre, se viene aggiunta anche la riga:
restricted
LILO chiederà la password ogni volta che si cercherà di fornirgli degli argomenti. Dal momento
che la password viene scritta in chiaro, il file dovrà essere accessibile solo da ‘root’.
388.6.12) ‘Error 0x10’ - visualizzazione di ripetuti 01 con LILO
In questi casi si deve controllare che:
• il disco fisso contenente GNU/Linux sia impostato nel BIOS con la modalità LBA attivata;
• la partizione radice (root) risieda entro il cilindro 1024. Se così non è, LILO non funziona.
28
388.6.13) Da cosa può dipendere se si riceve la segnalazione della presenza di un virus nel
settore di avvio (boot)?
Qualora all’avvio del sistema, dopo che sia stato scelto il sistema operativo desiderato mediante
LILO, si presenti un messaggio che indichi che è stato rilevato un virus nel settore di avvio (boot),
occorre disattivare dal BIOS, il controllo dei virus. Il BIOS confonde LILO con un virus. Se dopo
tale operazione, il problema persistesse è probabile allora che ci sia un virus.
388.6.14) Ci sono delle valide alternative a LILO?
LILO è solo uno dei tanti gestori degli avvii (boot loader). Tra gli altri gestori liberi ricordiamo:
• GRUB; 29
• GAG; 30
• Smart BootManager; 31
28
Come già accennato, le recenti versioni di LILO non hanno più questa limitazione.
GNU GRUB GPL
30
GAG GPL
31
Smart BootManager GPL
29
• Psiko. 32
Figura 388.5. Una schermata di GAG.
32
Psiko GPL
4459
4460
Alternativamente, si deve sempre ricordare che è possibile avviare GNU/Linux tramite un
dischetto di avvio (boot) o tramite Loadlin.
388.7 Kernel
388.7.1) Come si può sapere quale è l’ultima versione del kernel?
Si può fare mediante ‘finger’:
[bigpaul@localhost /~]$ finger @linux.kernel.org[ Invio ]
o:
[bigpaul@localhost /~]$ finger @finger.kernel.org[ Invio ]
e verrà restituito qualcosa simile a questo:
[linux.kernel.org]
The latest stable version of the Linux kernel is:
The latest beta version of the Linux kernel is:
The latest prepatch (alpha) version *appears* to be:
2.2.12
2.3.18
none
4461
Figura 388.8. Il comando finger.
388.7.2) Come si visualizza la versione del kernel in uso?
Si visualizza con ‘uname’ seguito dall’opzione -n :
[bigpaul@localhost /~]$ uname -r[ Invio ]
388.7.3) Come è possibile conoscere il nome del file dell’immagine del kernel che è stata
caricata?
Esiste la variabile BOOT_IMAGE di LILO che contiene il file dell’immagine del kernel che è
stata caricata. Purtroppo essa viene azzerata da qualche processo, per cui dopo il login risulta
vuota. Bisogna usarla prima di ‘depmod’ in ‘rc.sysinit’ per visualizzarne il valore.
Si deve ricordare comunque che con:
# uname -a[ Invio ]
viene restituita una riga di questo tipo:
Linux server 2.2.13 #4 Sun Nov 21 14:13:37 CET 1999 i586 unknown
da cui è possibile capire almeno la versione del kernel utilizzato.
388.7.4) Come si ricompila il kernel?
La metodica qui di seguito spiegata si riferisce sia alla ricompilazione di un kernel già in utilizzo,
sia alla ricompilazione di una nuova versione.
Qualora si intenda ricompilare il kernel gi presente nel sistema, occorre assicurarsi che nella
directory ‘/usr/src’ sia generalmente presente un collegamento simbolico chiamato ‘linux’
che punti alla directory che contiene tutti i sorgenti del kernel installato. A volte non è presente
tale collegamento simbolico ma c’è direttamente la directory ‘linux’. Qualora non sia presente
nessuno dei due, occorre individuare la directory contenente i sorgenti e creare in ‘/usr/src’
un collegamento simbolico chiamato ‘linux’ che vi punti.
4462
Se si deve invece ricompilare una nuova versione del kernel, si deve copiare il pacchetto in
‘/usr/src’ e successivamente si deve decomprimerlo mediante:
# cd /usr/src/[ Invio ]
# tar -zxvf pacchetto.tar.gz[ Invio ]
In questo modo verrà creata una nuova directory chiamata ‘linux’ dove sono presenti i sorgenti
del nuovo kernel. Se la directory creata dal processo di decompressione non si chiama ‘linux’,
si dovrà rinominarla:
# mv directory_creata linux[ Invio ]
o creare un collegamento simbolico simbolico ad essa:
# ln -s directory_creata linux[ Invio ]
Ora occorre entrare nella directory ‘/usr/src/linux’ (collegamento simbolico o directory che
sia) e si devono eseguire questi comandi:
# make mrproper[ Invio ]
(Questo comando cancella il file ‘.config’ riazzerando tutte le opzioni selezionate nell’ultimo
tentativo di ricompilazione.) 33
# make menuconfig[ Invio ]
se si vuole una schermata interattiva testuale, oppure, per una schermata grafica:
# make xconfig[ Invio ]
Figura 388.9. make xconfig.
A questo punto si devono scegliere tutte le componenti che si desiserano utilizzare e il supporto
per le periferiche di cui si dispone. A scelta ultimata, si salva la configurazione (che verrà salvata
nel file ‘.config’) e si impartiscono i seguenti comandi:
# make dep[ Invio ]
# make clean[ Invio ]
# make bzImage[ Invio ]
33
Si deve ricordare che questo è un comando facoltativo, infatti se vogliamo ricompilare il kernel una seconda volta modificando pochissimi valori dall’ultima ricompilazione, il comando sopra indicato, cancellerà tutte le ultime impostazioni.
Se lo omettiamo quindi, ritroveremo tutte le opzioni selezionate in precedenza.
4463
che possono essere anche inclusi tutti insieme in un unico comando:
# make dep clean bzImage[ Invio ]
Conviene fare:
e non:
# make zImage[ Invio ]
perché il secondo comando crea un’immagine del kernel più grande che il LILO può non
accettare; per cui conviene subito compilare con l’opzione ‘bzImage’.
Se alcune componenti sono state dichiarate come modulo, va dato il comando:
# make modules[ Invio ]
e subito dopo:
# make modules_install[ Invio ]
A questo punto l’immagine del kernel sarà stata creata nella directory ‘/usr/src/linux/
arch/i386/boot’ con il nome ‘bzImage’.
L’immagine va copiata nella directory ‘/boot/’:
# cp bzImage /boot[ Invio ]
Si deve in seguito modificare opportunamente il file ‘/etc/lilo.conf’ indicando il nuovo nome dell’immagine. Nella sezione corrispondente al sistema GNU/Linux si deve inserire il nome
del file dell’immagine dopo:
image=
Se ad esempio non si è rinominato il file dell’immagine, si dovrà inserire la riga seguente:
image=bzImage
Le modifiche effettuate al file ‘/etc/lilo.conf’ non saranno effettive fino a che non si lancia
‘lilo’:
# /sbin/lilo[ Invio ]
A questo punto al riavvio, partirà la nuova versione del kernel.
388.7.5) Come funziona la ricompilazione del kernel in una distribuzione GNU/Linux
Debian?
In una distribuzione GNU/Linux Debian, la gestione del kernel presenta una particolarità sebbene
sia sempre possibile operare in maniera convenzionale come indicato nella LDR 388.7.4. La particolarità consiste nella possibilità di creare pacchetti Debian del proprio kernel con il vantaggio
quindi di potere installare e disinstallare rapidamente diversi pacchetti del kernel e specialmente
di potere facilmente utilizzare la stessa immagine su più macchine.
Per fare ciò, è necessario installare i pacchetti ‘kernel-package’ e ‘bin86’. La descrizione del
pacchetto ‘kernel-package’ è la seguente:
4464
This package provides the capability to create a debian kernel-image
package by just running make-kpkg kernel_image in a kernel source directory
tree. It can also build the kernel source package as a debian file, the
kernel headers package. In general, this package is very useful if you need
to create a custom kernel, if, for example, the default kernel does not
support some of your hardware, or you wish a leaner, meaner kernel.
If you are running on an intel x86 platform, and you wish to compile a
custom kernel (why else are you considering this package?), then you may
need the package bin86 as well. (This is not required on other platforms).
Questo pacchetto consente di poter creare un pacchetto debian contenente
l’immagine del kernel. Esso può inoltre creare un file debian,
il pacchetto delle intestazioni del kernel, da un pacchetto
del sorgente del kernel. In generale, questo pacchetto è molto utile
se avete bisogno di creare kernel personalizzati, se ad esempio, il
kernel predefinito non gestisce una parte del vostro hardware, o se aveste
bisogno di un kernel più piccolo.
Se state utilizzando una piattaforma intel x86, e vorreste compilare
un kernel personalizzato (altrimenti perché dovreste considerare questo pacchetto?),
allora avrete bisogno anche del pacchetto bin86. (Non richiesto
per altre piattaforme).
Una volta installati i suddetti pacchetti, si seguono tutti i passaggi indicati nella LDR 388.7.4 fino
a ‘make menuconfig’ (o ‘make xconfig’). Non serviranno quindi i seguenti comandi: ‘make
dep’, ‘make clean’, ‘make zlilo’, ‘make modules’, ‘make modules install’.
A questo punto, per creare il pacchetto personalizzato, si deve impartire il seguente comando:
# make-kpkg nome[ Invio ]34
Nella directory esterna ai sorgenti del kernel sarà ora presente un pacchetto ‘deb’ contenente il
kernel compilato e tutti i moduli necessari.
Disponendo ora di un pacchetto ‘deb’, lo si può installare:
# dpkg -i /usr/src/nome[ Invio ]
Per verificarne il funzionamento, si dovrà riavviare il sistema:
Oltre al pacchetto del kernel, ‘make-kpkg’ è in grado di generare pacchetti Debian particolari:
• ‘kernel-headers’ (‘.h’ per compilare programmi dipendenti dal kernel)
• ‘kernel-source’ (crea un pacchetto con i sorgenti del kernel)
• ‘kernel-doc’ (documentazione del kernel)
Occorre prestare attenzione a Dselect, che potrebbe sovrascrivere il proprio kernel. Per ovviare
a tale problema, premere il tasto [ = ] sul pacchetto ‘kernel-image’ installato; in questo modo
Dselect o ‘dpkg’ non potrà sostituirlo.
34
dove ‘nome’ è il nome del pacchetto appena creato.
4465
388.7.6) Cosa succede se copio la nuova immagine del kernel in ‘/boot’ ma lì c’è la
vecchia immagine?
Non è importante che l’immagine del kernel abbia sempre lo stesso nome. Si possono infatti
copiare nella directory ‘/boot/’ diversi file immagine. Sarà allora compito del gestore degli
avvii (boot manager) richiamare le immagini desiderate all’avvio del sistema.
Se ad esempio disponiamo di un file ‘/etc/lilo.conf’ configurato nel seguente modo:
boot=/dev/hda
map=/boot/map
prompt
timeout=50
image=/boot/bzImage-2.2.0
label=predefinto
root=/dev/hda1
read-only
image=/boot/bzImage-2.2.5-15
label=prova
root=/dev/hda1
read-only
nella directory ‘/boot/’ saranno presenti i due file immagine ‘bzImage-2.2.0’ e
‘bzImage-2.2.5-15’ che saranno invocati dal prompt di LILO mediante le etichette
‘predefinito’ e ‘prova’. Si può notare che le due voci puntano alla stessa directory radice
per cui si fornisce la scelta di due immagini del kernel diverse per lo stesso sistema GNU/Linux.
388.7.7) Quanto spazio occupa il sorgente del kernel? Si può cancellare dopo la
ricompilazione?
I sorgenti decompressi occupano circa 60-70 Mibyte.
388.7.8) Come si applica una patch al kernel?
L’applicazione di una patch al kernel risulta una operazione molto comoda in quanto consente di
evitare lo scaricamento dell’intero sorgente che è generalmente di grosse dimensioni.
Per applicare una patch al kernel, si deve innanzitutto copiare il file di modifiche (patch) all’interno della directory ‘/usr/src/’. Entrati quindi nella stessa directory mediante il
comando:
# cd /usr/src[ Invio ]
applichiamo il file di modifiche (patch):
# bzip2 -dc nomefile.bz2 |patch -p1[ Invio ]
o:
# gzip -dc nomefile.gz |patch -p0[ Invio ]
se è in formato ‘.gz’.
Oltre a questa metodica, si può ricorrere all’eseguibile ‘patch-kernel’ presente nella directory
‘/usr/src/linux/scripts/’. Con questa metodica, come nella precedente, si copiano i file
di modifiche (patch) nella directory ‘/usr/src/’ e si lancia l’eseguibile ‘patch-kernel’:
4466
# cd /usr/src/linux/scripts/patch-kernel[ Invio ]
‘patch-kernel’ è in pratica uno script che provvede a cercare i file di modifiche (patch) nella
directory ‘/usr/src/’ e ad applicarli.
388.7.9) Dopo avere applicato una patch al kernel, la procedura di ricompilazione subisce
dei cambiamenti?
No, dopo l’applicazione del file di modifiche (patch) tutti i file sono stati aggiornati e il sorgente del kernel che ne risulta è identico a quello della versione alla quale si è effettuato
l’aggiornamento.
In ogni caso è bene aggiornare la configurazione con il comando:
# make oldconfig[ Invio ]
388.7.10) Durante la ricompilazione del kernel, viene segnalata la mancanza di ‘wish’,
perché?
Wish non è altro che l’interprete Tcl. Occorre quindi installare il pacchetto ‘tk’ (toolkit Tk) che
in ogni caso necessita del pacchetto ‘tcl’ (Tool Command Language - TCL).
I pacchetti ora descritti vengono di solito forniti con qualsiasi distribuzione.
388.7.11) Dopo avere ricompilato il kernel, come è possibile provare senza rischio
l’immagine appena creata?
La seguente procedura presume che la ricompilazione sia già stata effettuata (388.7.4) e che
l’immagine del kernel rinominata in ‘bzImage-prova’ si trovi nella directory ‘/boot/’.
Il file ‘/etc/lilo.conf’ attuale dovrebbe somigliare a questo:
boot=/dev/hda
map=/boot/map
prompt
timeout=50
image=/boot/bzImage
\011label=linux
\011root=/dev/hda3
\011read-only
(eventuale altro sistema operativo)
‘bzImage’ (o qualsiasi altro nome) è il nome dell’immagine del kernel attuale e ‘/dev/hda3’ è
la partizione radice.
Se come si è detto la nuova immagine del kernel è stata copiata in ‘/boot/’, dovremo aggiungere
al file ‘lilo.conf’, un’altra sezione:
image=/boot/bzImage-prova
\011label=prova
\011root=/dev/hda3
\011read-only
Il file ‘lilo.conf’ risulterà quindi:
4467
boot=/dev/hda
map=/boot/map
prompt
timeout=50
image=/boot/bzImage
\011label=linux
\011root=/dev/hda3
\011read-only
image=/boot/bzImage-prova
\011label=prova
\011root=/dev/hda3
\011read-only
(eventuale altro sistema operativo)
Per rendere operative le modifiche apportate a ‘lilo.conf’, si dovrà rilanciare LILO:
# lilo -v[ Invio ]35
Al riavvio del sistema, al prompt di LILO digitando ‘prova’ verrà avviata la nuova immagine
del kernel. Qualora la nuova immagine non funzionasse a dovere, sarà sempre possibile utilizzare
l’etichetta ‘linux’ (in ogni caso la predefinita) per caricare la vecchia immagine del kernel.
Prima di eliminare la vecchia immagine del kernel, è consigliato un certo periodo di prova. Una
volta sicuri del funzionamento della nuova configurazione sarà possibile rimuovere la sezione:
image=/boot/bzImage
\011label=linux
\011root=/dev/hda3
\011read-only
dal file ‘/etc/lilo.conf’ e sostituire ‘prova’ con ‘linux’. Ricordarsi sempre, dopo qualsiasi
modifica al file di configurazione di LILO, di impartire:
# lilo -v[ Invio ]
per rendere effettive le modifiche.
388.7.12) Si può trasportare l’immagine del kernel da una distribuzione ad un’altra?
Se l’immagine del kernel da spostare include il supporto per caratteristiche del sistema ricevente,
sarà un’operazione possibile. Per poter spostare il kernel sono necessari:
• il file ‘bzImage’ (l’immagine del kernel, presente generalmente in ‘/boot/’, può assumere
qualsiasi nome);
• la directory ‘/usr/src/linux/include/’;
• la directory ‘/lib/modules/x.x.xx’ relativa alla versione del kernel che si sta spostando.
‘kernel-package’ (388.7.5) di una distribuzione Debian GNU/Linux consente di creare un
pacchetto ‘deb’ di tutte le componenti di un kernel. L’utilizzo quindi dello stesso kernel, su più
sistemi, risulterà quindi più semplice e versatile.
35
-v abilita la modalità prolissa
4468
388.7.13) A cosa serve il file ‘initrd-x.x.xx.img’ nella directory ‘/boot’?
La guida The Official Red Hat Linux Reference Guide riporta quanto segue:
An initrd image is needed for loading your SCSI module at boot time. The shell script
/sbin/mkinitrd can build a proper initrd image for your machine if the following conditions are
met:
The loopback block device is available.
The /etc/conf.modules file has a line for your SCSI adapter; for example: alias scsi_hostadapter
BusLogic
Viene richiesta un’immagine initrd per caricare il vostro modulo SCSI all’avvio. Lo script
/sbin/mkinitrd può costruire un’immagine initrd corretta per la vostra macchina se si presentano
le seguenti condizioni:
È disponibile il dispositivo di blocco del loopback
Il file /etc/conf.modules presenta una riga per l’adattatore SCSI; ad esempio: alias
scsi_hostadapter BusLogic
‘initrd-x.x.xx.img’ è quindi un’immagine utilizzata per caricare il modulo SCSI all’avvio.
La si può creare con il comando ‘/sbin/mkinitrd’.
388.7.14) Il kernel di Linux è in grado di gestire periferiche USB?
Occorre avere come minimo un kernel 2.2.14 con il backport oppure un 2.3.xx .
388.7.15) Come è possibile ottimizzare il kernel per macchine con processore Pentium?
Lo si può fare modificando il makefile che si trova in ‘/usr/src/linux’. In pratica bisogna
cercare le voci:
• HOSTCFLAGS
• MAKE
• CFLAGS
e modificare il loro contenuto nel seguente modo:
HOSTCFLAGS
=-Wall -Wstrict-prototypes -O3 -march=pentium -mcpu=pentium -ffa
st-math -funroll-loops -fomit-frame-pointer -fforce-mem -fforce-addr -malign-dou
ble -fno-exceptions
MAKE
=make -j 4
CFLAGS := $(CPPFLAGS) -Wall -Wstrict-prototypes -O3 -march=pentium -mcpu=pentium
-ffast-math -funroll-loops -fomit-frame-pointer -fforce-mem -fforce-addr -malig
n-double -fno-exceptions
(nella versione 2.3.47 si trova CFLAGS := $(CPPFLAGS) mentre fino alla 2.2.14 c’è solo
CFLAGS =).
È da notare che si deve utilizzare come compilatore ‘pgcc’ (un compilatore gcc ottimizzato per
processori pentium).
4469
388.7.16) Dove si trovano i sorgenti del kernel?
I sorgenti del kernel si trovano generalmente nella directory ‘/usr/src/linux’.
388.7.17) Perché sopraggiungono dei problemi relativi a ‘ipfwadm’ con i kernel della serie
2.2.x ?
Perché dai kernel della serie 2.2.x , non si usa più ‘ipfwadm’ ma ‘ipchains’.
388.7.18) Perché nei kernel della serie 2.2.x non è presente l’opzione drop source-routed
frames ?
La risposta è tratta dal file ‘/usr/src/linux/Documentation/Changes’:
In 2.0.x the kernel could be configured to drop source routed IP
packets via a compile time configuration option. In 2.2.x, this has
been replaced by a sysctl.
Nei kernel della serie 2.0.x ci potrebbe essere la configurazione
che (ri)lasci i pacchetti IP sorgenti (originali) instradati
mediante un’opzione di configurazione del tempo di compilazione.
Nella serie 2.2.x, questa caratteristica è stata sostituita da
una sysctl.
388.7.19) Come si verifica quali sono i pacchetti RPM del kernel installati?
Con il comando:
# rpm -qa | grep kernel | sort[ Invio ]
388.7.20) Come si possono memorizzare gli eventuali messaggi (di errore e non) che
possono risultare dalla procedura di ricompilazione del kernel?
Durante la ricompilazione del kernel, possono verificarsi numerose problematiche che vengono
di solito visualizzate mediante messaggi. Con il comando:
# make dep;make clean;make bzImage > LOG-k 2> ERR-k;make modules >
LOG-m 2> ERR-m[ Invio ]
sarà possibile registrare nei file ‘LOG-k’ e ‘LOG-m’ gli avvertimenti e gli errori verificatesi durante
la ricompilazione del kernel e l’installazione dei moduli.
Risulterà quindi più facile individuare i problemi e le cause degli errori.
388.7.21) Perché dopo la ricompilazione del kernel c’è una diminuzione dello spazio nel
disco?
La ricompilazione del kernel comporta una diminuzione dello spazio su disco di circa
20 - 30 Mibyte.
Per recuperare lo spazio, occorre dare:
# make clean[ Invio ]
dopo essersi posizionati in ‘/usr/src/linux’.
4470
388.7.22) Dove devo copiare il file ‘System.map’ e che operazioni devo compiere su di
esso?
Il file ‘System.map’ si viene a trovare nella directory ‘/usr/src/linux/’ alla fine del processo
di ricompilazione del kernel e va copiato nella directory ‘/boot/’. Per ogni immagine del kernel,
esiste un ‘System.map’ diverso. Occorre quindi provvedere, nel caso si desideri utilizzare più
di un’immagine del kernel nel proprio sistema, a sostituire i vari file ‘System.map’ a seconda
dell’immagine del kernel che si sta utilizzando.
Un modo per fare questo è rinominare i vari ‘System.map’ in ‘System.map.x.y.z’36 , e creare
ogni volta un collegamento simbolico che punti al ‘System.map.x.y.z’ desiderato.
Se ad esempio si è appena ricompilato il kernel 2.2.12 occorrerà copiare in ‘/boot/’ l’immagine
del kernel e il file ‘System.map’ rinominando quest’ultimo in ‘System.map.2.2.12’:
# cp /usr/src/linux/arch/i386/boot/bzImage /boot/[ Invio ]
e:
# cp /usr/src/linux/System.map /boot/System.map.2.2.12[ Invio ]
Occorrerà quindi creare il collegamento simbolico in ‘/boot’:
# ln -s /boot/System.map.2.2.12 /boot/System.map[ Invio ]
lrwxrwxrwx
-rw-r--r--
1 root
1 root
root
root
19 Jun
186846 Jun
5 14:38 System.map -> System.map.2.2.12
5 14:30 System.map-2.2.12
388.7.23) Come si possono gestire più file ‘System.map’ quando si dispone di più
immagini del kernel?
Per far sì che il sistema carichi all’avvio i file ‘/boot/System.map’ corretti a seconda dell’immagine del kernel che si è scelto di caricare, si dovrà modificare il file ‘/etc/rc.d/init.d/
syslog’ (‘/etc/init.d/sysklogd’ in una distribuzione Debian).
La riga:
daemon klogd -k /boot/System.map
dovrà essere sostituita con:
daemon klogd -k /boot/System.map-‘uname -r‘
Ora si devono copiare in ‘/boot’ i file ‘System.map’ dei rispettivi kernel, rinominandoli nel
seguente modo:
# mv System.map System.map-x.y.z[ Invio ]37
388.7.24) Perché il sistema mi avverte che la versione del file ‘System.map’ è sbagliata?
Ogni immagine del kernel, ha un ‘System.map’ che vi si riferisce. Probabilmente in ‘/boot/’
c’è un ‘System.map’ che non si riferisce all’immagine del kernel caricata. Questo di solito accade se si dimentica di copiare il file ‘System.map’ presente in ‘/usr/src/linux/’ in ‘/boot/’
al termine della ricompilazione del kernel.
36
x ,y e z identificano la versione del kernel cui il file ‘System.map’ fa riferimento
x , y e z identificano la versione del kernel; La versione dell’immagine del kernel caricata, si può rilevare mediante
il comando ‘uname -r’.
37
4471
Qualora si intenda utilizzare sempre e solo l’ultima immagine creata dal kernel, conviene rendere ‘/boot/System.map’ un collegamento simbolico a ‘/usr/src/linux/System.map’; in
questo modo ogni volta che il kernel verrà aggiornato, il collegamento farà sempre riferimento
all’ultima versione di ‘System.map’ e non verranno più segnalati problemi di incongruenza.
388.7.25) as86 Command not found
Questo errore si verifica nella fase di creazione dell’immagine del kernel, dopo il comando:
In genere viene visualizzato qualcosa del genere:
make[1]: Entering directory ’/linux/arch/i386/boot’
as -0 -a -o bootsect.o bootsect.s
make[1]: as86: command not found
make[1]: *** [bootsect.o] Error 127
make[1]: Leaving directory ’/linux/arch/i386/boot’
make: *** [zImage] Error 2
Il problema si presenta perché manca il pacchetto ‘bin86’ di cui ‘as86’ fa parte.
388.7.26) /dev/lp0 :not detected
Spesso dopo l’aggiornamento del kernel da una versione 2.0.x ad una 2.2.x , capita di ricevere
segnalazioni analoghe alla seguente:
/dev/lp0 :not detected
Se non viene riconosciuta la porta parallela può dipendere dal fatto che in ‘/etc/
conf.modules’ manca la riga riguardante il modulo ‘parport_pc.o’. Occorre quindi
aggiungere al file suddetto le seguenti righe:
alias parport_lowlevel parport_pc
options parport_pc io=0x378,0x278 irq=7,auto
modificando opportunamente gli indirizzi con quelli del proprio sistema.
388.7.27) signal 11
Se durante operazioni abbastanza impegnative per il sistema (la ricompilazione del kernel ad
esempio), si ricevono messaggi quali:
Internal compiler error: program cc1 got fatal signal 11</em>
È bene prendere in considerazione il fatto che ci possano essere dei problemi di
malfunzionamento della RAM. Potrebbe essere difettosa.
4472
388.7.28) No setup Signature found
Questo messaggio generalmente appare non appena l’immagine del kernel comincia ad essere
caricata. Esso è la manifestazione del fatto che l’immagine del kernel non è stata predisposta ad
utilizzare il file system principale desiderato. A tale scopo si utilizza il programma ‘rdev’:
# rdev /boot/bzImage /dev/partizione [ Invio ]
Occorrerà sostituire ‘/boot/bzImage’ con la posizione dell’immagine del kernel all’interno del
file system (‘/boot/vmlinuz’, ‘/boot/vmlinuz-2.2.9’, ‘/boot/zImage’, ecc.). partizione
dovrà essere sostituita dal nome del dispositivo della partizione radice.
388.8 Moduli
388.8.1) Cosa si deve fare per i moduli dopo la ricompilazione del kernel?
I moduli devono essere installati e lo si fa mediante il comando:
# make modules modules_install[ Invio ]
dopo avere dato:
Questo comando crea la directory ‘/lib/modules/x.y.z’. 38
388.8.2) Come si possono caricare i moduli del kernel all’avvio?
Se ad esempio si intende caricare il modulo ‘ip_masq_ftp.o’ ad ogni avvio del sistema invece
di impartire ogni volta:
# modprobe ip_masq_ftp[ Invio ]
è necessario inserire la riga:
/sbin/modprobe ip_masq_ftp.o
all’interno del file ‘/etc/rc.d/rc.local’ o nei file corrispondenti delle diverse distribuzioni.
388.8.3) modprobe: can’t locate module...
Se nel file ‘/var/log/messages’ sono presenti messaggi simili a questi:
‘May 7 20:59 linuxfaq.it modprobe: can’t locate module ppp-compress-21’
per rimuoverli è necessario inserire le seguenti righe nel file ‘/etc/modules.conf’:
alias ppp-compress-21 bsd-comp
alias ppp-compress-26 ppp_deflate
alias ppp-compress-24 ppp_deflate
38
x , y e z identificano la versione del kernel.
4473
388.9 Configurazione del sistema
388.9.1) Come è possibile mantenere sulla propria macchina più di una distribuzione
GNU/Linux?
Verrà qui spiegato come poter gestire attraverso LILO L’avvio di due distribuzioni GNU/Linux
installate sulla stessa macchina. Come esempio si prenderà in considerazione l’ipotesi di poter
avviare una distribuzione GNU/Linux Debian e una Red Hat.
Nel file ‘/etc/lilo.conf’ , dovranno essere presenti due sezioni distinte, una per Debian e una
per Red Hat.
All’interno della directory ‘/boot/’ della distribuzione da cui si impartirà ‘lilo’, ammettiamo
che sia Debian ad esempio, dovranno essere presenti tutte e due le immagini del kernel con i
rispettivi ‘System.map’. Questi ultimi dovranno essere rinominati in ‘System.map.x.y.z’ in
cui x , y e z identificano la versione del kernel cui si riferiscono. Inoltre, in ‘/lib/modules/’
della stessa distribuzione Debian, dovranno essere copiate le directory dei moduli di Red Hat. In
pratica la directory ‘x.y.z/’ presente in ‘/lib/modules/’ della distribuzione Red Hat, dovrà
essere copiata all’interno della directory ‘/lib/modules/’ della distribuzione Debian.
Il file ‘/etc/lilo.conf’ assumerà questo aspetto:
boot=/dev/hda
map=/boot/map
prompt
timeout=50
password=**********
restricted
default=linux
image=/boot/vmlinuz-2.2.15
label=debian
root=/dev/hda2
read-only
image=/boot/vmlinuz-2.2.12
label=redhat
root=/dev/hdc5
read-only
Da questo file si deduce che:
• LILO verrà installato sulla prima partizione del primo disco della catena IDE/EIDE;
• LILO mostrerà il prompt per 5 secondi prima di avviare la distribuzione Debian presente
sulla seconda partizione del primo disco della catena IDE/EIDE;
• le etichette per avviare le due distribuzioni sono rispettivamente ‘debian’ e ‘redhat’;
• la partizione radice della distribuzione Red Hat si trova nella quinta partizione del terzo
disco della catena IDE/EIDE;
Per verificare tutte le impostazioni prima di avviare ‘lilo’ controlliamo le directory dei moduli:
[bigpaul@localhost]$ ls /lib/modules[ Invio ]
total 2
drwxr-xr-x
drwxr-xr-x
6 root
11 root
root
root
1024 Oct 31 18:34 2.2.12/
1024 Oct 27 01:59 2.2.15/
4474
Controlliamo anche che nella directory ‘/boot/’ siano presenti le immagini del kernel delle due
distribuzioni e i relativi file ‘System.map’:
[bigpaul@localhost]$ ls /boot[ Invio ]
total 2735
-rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-------rw-r--r--rw-r--r--
1
1
1
1
1
1
1
1
root
root
root
root
root
root
root
root
root
root
root
root
root
root
root
root
149820
186846
512
4544
612
26624
454123
617431
Oct
Apr
Oct
Apr
Apr
Nov
Oct
Apr
31
20
27
13
13
1
31
20
17:30
1999
01:55
1999
1999
15:31
17:30
1999
System.map-2.2.12
System.map-2.2.15
boot.0303
boot.b
chain.b
map
vmlinuz-2.2.12
vmlinuz-2.2.15
Occorre infine assicurarsi che nel file ‘/etc/rc.d/init.d/syslog’ (‘/etc/init.d/
sysklogd’ in una distribuzione Debian) la riga:
daemon klogd
sia sostituita da:
daemon klogd -k /boot/System.map-‘uname -r‘
per far riconoscere senza problemi ai vari kernel i propri ‘System.map’.
388.9.2) Esiste la deframmentazione in GNU/Linux?
I programmi per la deframmentazione del disco per GNU/Linux esistono ma non sono quasi
mai necessari e se ne sconsiglia l’uso. Normalmente la frammentazione di un file system Ext2 si
stabilizza tra il 4 e il 5 per cento, a meno che non ci sia una grande quantità di installazioni, ma
anche in questo caso non viene mai superato un certo limite.
Il metodo migliore e meno rischioso per deframmentare un disco, se proprio si desidera farlo, è
archiviare (su nastro o su qualsiasi altro supporto) tutto il contenuto del file system, cancellare il
file system stesso e ripristinare il contenuto dell’archivio.
388.9.3) Quali sono le differenze tra i file ‘/etc/profile’, ‘~/.bashrc’, ‘~/
.bash_profile’ e ‘~/.inputrc’?
Esistono principalmente due tipi di shell: interattiva e non interattiva. La prima è una shell in
cui l’utente è chiamato ad interagire con essa, ad inserire comandi. La shell non interattiva non
richiede l’intervento dell’utente ed è quella che viene eseguita durante l’esecuzione di uno script.
La shell interattiva si divide a sua volta in shell di login e shell normale. La prima consiste in
quello che si ha di fronte quando è stata completata la procedura di accesso.
A seconda del tipo di shell, verranno letti diversi tipi di file:
Se è una shell di login, se ‘/etc/profile’ esiste, lo legge; se ‘~/.bash_profile’ esiste, lo
legge, altrimenti se ‘~/.bash_login’ esiste, lo legge, altrimenti se ‘~/.profile’ esiste, lo
legge. Se all’uscita dalla shell ‘~/.bash_logout’ esiste, lo legge.
Se è una shell non di login, all’avvio se ‘~/.bashrc’ esiste, lo legge.
Infine se si tratta di una shell non interattiva, se la variabile di ambiente ENV non è nulla, la
espande e legge il file che indica, come se fosse stato eseguito il comando:
4475
if [ "$ENV" ]; then . $ENV; fi
Ecco un estratto della pagina di manuale di bash(1) relativamente ai file letti dai vari tipi di shell:
/etc/profile
Il file di inizializzazione generale per il sistema, eseguito per le shell di login
~/.bash_profile
Il file di inizializzazione personale, eseguito per
le shell di login
~/.bashrc
Il file di inizializzazione individuale per shell
interattiva
~/.inputrc
Il file di inizializzazione individuale per readline
‘readline’ è la libreria che gestisce la lettura dell’input quando si usa una shell interattiva.
388.9.4) Come si rendono disponibili anche per gli utenti le modifiche fatte al file ‘/etc/
bashrc’?
Per fare questo, occorre inserire nel file ‘.bashrc’ dell’utente le seguenti righe:
if [ -f /etc/bashrc ]; then
. /etc/bashrc
fi
388.9.5) Dopo aver modificato un file di configurazione, è necessario riavviare il sistema
per rendere effettive le modifiche?
No, è necessario invocarlo mediante l’eseguibile ‘source’:
# source .bashrc[ Invio ]
oppure ad esempio:
# source ~/.bash_profile[ Invio ]
Per ricaricare tutti i file di configurazione relativi alla shell, sia essa interattiva (di login o meno) che non interattiva, sarà sufficiente fare riferimento alla LDR 388.9.3 per sapere quali file
ricaricare mediante ‘source’.
388.9.6) Perché alcune modifiche apportate al sistema durante situazioni di emergenza
non sono riscontrabili al riavvio?
Questo succede generalmente perché non si è scaricata la memoria cache, quindi le modifiche
sono rimaste nella RAM e non sono state applicate. Per fare scrivere effettivamente quello che si
è fatto, occorre digitare:
# sync[ Invio ]
In ogni caso è bene riavviare mediante il comando:
e non tramite il pulsante ‘reset’. Anche in situazioni di emergenza, se si possono fare modifiche
al file system, si può anche avviare lo spegnimento.
4476
388.9.7) Come vengono gestiti i servizi in una distribuzione GNU/Linux Debian?
I servizi di una distribuzione GNU/Linux Debian sono gestiti dagli script e dai collegamenti simbolici presenti all’interno delle directory ‘/etc/rcx.d/’ , dove x assume i valori S,0,1,2,3,4,5,6
e della directory ‘/etc/init.d/’.
In particolare, in ‘/etc/init.d/’ saranno raccolti tutti gli script che si intende lanciare durante
la fase di avvio. Per poterli eseguire durante tale fase però, occorrerà creare un collegamento
simbolico (link) all’interno della directory relativa al livello di esecuzione (runlevel) impostato.
Se quest’ultimo è ad esempio il livello di esecuzione numero 3, il collegamento simbolico dovrà
essere posto in ‘/etc/rc3.d/’.
388.9.8) Come si lancia un programma durante la fase di avvio di una distribuzione
GNU/Linux Debian?
Per eseguire un programma durante la fase di avvio, occorrerà creare uno script che invochi
il programma stesso. Lo script dovrà essere collocato nella directory ‘/etc/init.d’ e dovrà
essere richiamato da collegamenti simbolici ad esso presenti nella directory del livello di esecuzione (runlevel) impostato. Se quest’ultimo è ad esempio il livello di esecuzione numero 3, il
collegamento simbolico dovrà essere posto in ‘/etc/rc3.d/’.
388.9.9) Come vengono gestiti i servizi in una distribuzione GNU/Linux Red Hat?
In Red Hat e nelle distribuzioni da essa derivate, nella directory ‘/etc/rc.d/’ esistono le directory dei vari livelli di esecuzione (runlevel); esse sono caratterizzate dal nome ‘rcx.d’ dove x
può assumere i seguenti valori:
• 0: livello di spegnimento;
• 1: livello monoutente;
• 2,3: livelli di lavoro;
• 5: livello modalità grafica;
• 6: livello di riavvio.
Oltre alle suddette directory c’è la directory ‘/etc/rc.d/rc.local/’. Queste directory contengono dei collegamenti simbolici a script presenti nella directory ‘/etc/rc.d/init.d/’. Praticamente, se in ‘/etc/rc.d/rc.local/’ si inserisce un collegamento simbolico ad uno script
presente in ‘/etc/rc.d/init.d/’, ad ogni avvio questo verrà eseguito; se se ne inserisce un
altro in ‘/etc/rc.d/rc3.d/’ questo verrà eseguito quando il sistema sarà avviato in livello di
esecuzione (runlevel) 3 e verrà terminato allo spegnimento del sistema, al riavvio o se si passerà
ad un altro livello di esecuzione.
Bisogna ricordare che i nomi dei collegamenti simbolici agli script presenti nella directory
‘/etc/rc.d/init.d/’ sono nomi codificati. Essi infatti sono composti da una lettera maiu-
scola iniziale (S o K), da un numero e dal nome dello script cui puntano. La lettera (S o K)
determina rispettivamente l’avvio o il non avvio dello script ed il numero ne determina invece
l’ordine di esecuzione.
Se ad esempio nella directory ‘/etc/rc.d/rc3.d/’ sono presenti:
4477
K75netfs -> ../init.d/netfs
S10network -> ../init.d/network
S50inet -> ../init.d/inet
all’avvio con livello di esecuzione (runlevel) 3, «netfs» non verrà eseguito (la «K» nel nome
del collegamento ne nega l’esecuzione), mentre «network» e «inet» saranno eseguiti seguendo
l’ordine indicato dal numero dopo la «S».
388.9.10) Come si possono disattivare i servizi in Red Hat?
All’interno della directory ‘/etc/rc.d/rcx.d/’ 39 , sono presenti i collegamenti simbolici agli
script dei servizi collocati all’interno della directory ‘/etc/rc.d/init.d/’.
Con il comando:
# ls -l /etc/rc.d/rc3.d/[ Invio ]40
risulteranno evidenti i collegamenti simbolici. Questi collegamenti come già descritto nella LDR
388.9.9 sono fatti nel seguente modo: sono composti da una lettera maiuscola iniziale (S o K),
da un numero e dal nome dello script cui puntano. La lettera (S o K) determina rispettivamente
l’avvio o il non avvio dello script ed il numero ne determina invece l’ordine di esecuzione.
Per disattivare un servizio, basterà quindi sostituire la «S» con la «K» o eliminare il collegamento
simbolico.
388.9.11) Come si fanno ripartire i demoni se si sono modificati i file di configurazione?
Occorre individuare il PID del demone attraverso il comando ‘ps’:
# ps -aux | grep demone[ Invio ]
Una volta trovato il PID, per riavviare il demone si darà il comando:
# kill -HUP PID [ Invio ]
Quest’ultimo in pratica arresta il processo del demone e lo fa ripartire, facendogli in questo modo
indirettamente rileggere i file di configurazione modificati.
Per riavviare, di solito si può anche mandare il sengale 1 al processo con il seguente comando:
# kill -1 PID [ Invio ]
In Apache ad esempio basta uccidere il primo dei processi attivi (definito ‘root’) per far ripartire
con le nuove impostazioni anche i processi figli.
Un modo ancora più pulito è andare nella directory ‘/etc/init.d/’ o ‘/etc/rc.d/init.d/’
e fare ripartire il demone usando lo script di inizializzazione, ad esempio:
# cd /etc/init.d/[ Invio ]
# ./apache restart[ Invio ]
39
40
dove x assume il valore del livello di esecuzione di cui si vogliono disattivare i servizi.
se il livello di esecuzione è il numero 3
4478
388.9.12) Come si cambia il nome della macchina?
Il nome della macchina che quasi sempre, in maniera predefinita, è ‘localhost’, può essere
sostituito modificando il file ‘/etc/hosts’. In questo file infatti è indicato l’indirizzo IP e il
nome della macchina. Questo esempio cambia il nome della macchina locale da ‘localhost’ a
‘miarete’ sostituendo la seguente riga del file ‘/etc/hosts’, con questa:
127.0.0.1
localhost
in (ad esempio):
127.0.0.1
miarete
388.9.13) Come si imposta l’orologio?
La data va impostata mediante il comando ‘date’:
# date 12070820[ Invio ]
Questo comando imposterà l’orario alle 08.20 del 7 Dicembre dell’anno corrente.
Per mantenere però queste impostazioni nel sistema, per aggiornare insomma l’orologio del
BIOS, si dovrà dare il comando:
# hwclock --systohc &[ Invio ]
Ricordiamo inoltre che ‘timeconfig’ è il programma di utilità per impostare l’orario di una
distribuzione Red Hat.
388.9.14) Come si mantiene aggiornato l’orologio?
Mantenere aggiornato l’orologio del sistema con server remoti preposti a tale scopo, è un’operazione che si fa mediante gli eseguibili ‘ntpdate’ e ‘rdate’. Se non presenti nel sistema,
andranno installati i relativi pacchetti: ‘ntpdate’ e ‘rdate’.
Dopo aver terminato il processo di ‘xntpd’ occorrerà dare il comando:
# ntpdate www.clock.org[ Invio ]
un comando simile è:
# rdate -sp tempo.cstv.to.cnr.it[ Invio ]
Per aggiornare l’orologio del BIOS, si dovrà in ogni caso dare il comando:
# hwclock --systohc &[ Invio ]
4479
388.9.15) Cosa si deve fare per impostare l’ora legale in GNU/Linux?
L’ora legale viene aggiornata automaticamente. È opportuno fare in modo che l’orologio interno dell’elaboratore sia posizionato sull’ora di riferimento definita dal GMT, (Greenwich Mean
Time).
388.9.16) Come si visualizza un calendario?
Per visualizzare il calendario del mese corrente:
$ cal[ Invio ]
Per visualizzare il calendario dell’anno corrente:
$ cal -y[ Invio ]
Per visualizzare il calendario dell’anno 2002:
$ cal 2002[ Invio ]
Per visualizzare solo il mese di Febbraio 2000:
$ cal 2 2000[ Invio ]
Figura 388.10. Il comando cal.
388.9.17) Come è possibile attivare ad ogni avvio la spia della tastiera relativa al tasto
[ BlocNum ]?
Se da BIOS non è possibile impostare la spia, si dovrà operare in maniera diversa a seconda della
distribuzione che si possiede.
Red Hat:
4480
Con questa distribuzione, si dovranno inserire nel file ‘/etc/rc.d/rc.sysinit’ le seguenti
righe:
for t in 1 2 3 4 5 6
do
/usr/bin/setleds -D +num < /dev/tty$t > /dev/null
done
oppure:
INITTY=/dev/tty[1-8]
for tty in $INITTY; do
setleds -D +num < $tty
done
Debian GNU/Linux:
In questa distribuzione, occorrerà creare uno script con le righe sopra esposte, e posizionarlo
nella directory ‘/etc/rc.boot’.
Slackware:
In questo caso lo script andrà inserito nel file ‘rc.keymap’.
388.9.18) Si può cancellare il contenuto della directory ‘/tmp/’ o è pericoloso?
Molti programmi in esecuzione, appoggiano alcuni file nella directory ‘/tmp/’. Può essere una
buona idea ripulire quella directory prima che qualsiasi programma possa scriverci qualcosa dentro. Ecco quindi che l’avvio del sistema risulta essere il momento opportuno. Si deve allora creare uno script da inserire nella directory del sistema contenente tutti i servizi (‘/etc/init.d/’,
‘/etc/rc.d/init.d/’, ecc.).
Alcune distribuzioni eseguono in maniera predefinita tale procedura. Lo script da inserire consta
semplicemente di una riga:
rm -rf /tmp/*
388.9.19) Come si visualizza lo spazio disponibile su disco?
A tale scopo si utilizza il comando ‘df’:
# df[ Invio ]
Il suddetto comando restituirà la percentuale di occupazione di ciascun file system montato, lo
spazio occupato e lo spazio residuo. Mediante l’opzione -h , lo spazio residuo verrà visualizzato
in maniera più chiara. L’opzione -T mostrerà anche il tipo di ogni file system.
388.9.20) Come si possono visualizzare le variabili d’ambiente?
Per visualizzare le variabili, occorre digitare:
# printenv[ Invio ]
oppure:
# set[ Invio ]
4481
388.9.21) Come si impostano le variabili d’ambiente?
Le variabili d’ambiente si impostano mediante il comando ‘export’:
# $ export VARIABILE=valore[ Invio ]
Ecco qualche esempio:
# export HOSTNAME="‘cat /etc/HOSTNAME‘"[ Invio ]
# export MOZILLA_HOME=/usr/lib/netscape[ Invio ]
# export MAILDIR=/var/spool/mail[ Invio ]
# export TERM=linux[ Invio ]
# export PS1=’\n\u@\h:[‘pwd‘] [\t] --> \!\n* ’[ Invio ]
388.9.22) Come si possono visualizzare le librerie usate da un programma?
Con il comando ‘ldd’:
# ldd programma[ Invio ]
388.9.23) Come mi devo comportare se un applicativo mi chiede una libreria di una
versione più vecchia di quella attualmente installata nel mio sistema?
Se un programma richiede una versione di una libreria più vecchia di quella installata nel proprio
sistema, a volte è sufficiente creare un collegamento simbolico alla libreria più vecchia. Il nome
del collegamento simbolico dovrà essere quello della libreria di versione precedente.
Se ad esempio un programma richiedesse le librerie ‘libjpeg’ 61 ma nel sistema fosse installata
solo la versione 62, sarebbe sufficiente creare nella directory ‘/usr/lib/’ un collegamento
simbolico alla libreria più recente:
# cd /usr/lib/[ Invio ]
# ln -s libjpeg.so.62 libjpeg.so.61[ Invio ]
388.9.24) C’è un modo per evitare di scrivere ogni volta comandi molto lunghi utilizzati di
frequente?
Per fare questo, occorre ricorrere agli alias. Questi ultimi non sono altro che dei nomi cui vengono
associati comandi che si usano frequentemente e che comunque presentano numerose opzioni,
difficili da ricordare o troppo lunghe da digitare. Per creare un alias è sufficiente il comando
‘alias’:
# alias ls=’ls -la --color’[ Invio ]
In questo caso basterà digitare ‘ls’ per avere un elenco dettagliato e colorato di tutti i file (anche
quelli nascosti). Se si intende mantenere gli alias, si dovranno inserire i comandi nel file ‘~/
.bash_profile’ se sono specifici per un utente, o nel file ‘/etc/profile’ se saranno tutti gli
utenti del sistema a poterne beneficiare.
4482
388.9.25) Esiste la possibilità di sospendere (ibernare) un sistema GNU/Linux?
Per abilitare questa funzione, bisogna includere tra le opzioni del kernel, il supporto per l’APM.
Per sospendere il sistema si dovrà dare il comando:
# apm --suspend[ Invio ]
388.10 Utenti e password
388.10.1) Dove sono raccolte le informazioni sugli utenti del sistema?
Queste informazioni sono raccolte nel file ‘/etc/passwd’. Se si usano le shadow password, si
dovrà controllare anche il file ‘/etc/shadow’.
388.10.2) Dove sono raccolte le informazioni sui gruppi di utenti del sistema?
L’elenco dei gruppi di utenti è contenuto nel file ‘/etc/group’. Se si usano le shadow password,
si dovrà controllare anche il file ‘/etc/gshadow’.
388.10.3) In che modo è possibile rimuovere un account di un utente?
Si può eliminare un utente dal sistema mediante il seguente comando:
# userdel IDutente[ Invio ]41
Alcune distribuzioni dispongono di ‘deluser’ al posto di ‘userdel’.
In ogni caso si deve ricordare che ogni utente possiede generalmente i propri dati nella directory ‘/home/utente’ e la sua presenza nel sistema dipende dalle impostazioni presenti nei file ‘/etc/passwd’ e ‘/etc/group’. L’eliminazione quindi di queste componenti, comporta in
effetti la rimozione dell’utente dal sistema.
388.10.4) Come si cancellano tutti i file di un utente presenti nel sistema?
Il comando è:
# find / -user uid -exec rm {} \;[ Invio ]42
oppure:
# find / -uid ‘id -u utente‘ | xargs rm -f[ Invio ]
Per evitare di commettere errori che potrebbero risultare spiacevoli è meglio controllare cosa
questo comando andrà a cancellare con:
# find / -user uid | less[ Invio ]
41
IDutente è il numero di identificazione dell’utente. Questo numero si può recuperare nel file ‘/etc/passwd’ o
mediante il comando ‘id -u utente’.
42
dove uid è il valore numerico dell’utente del quale vuoi cancellare i file; (da rilevare in ‘/etc/passwd’ o mediante
il comando ‘id -u utente’).
4483
388.10.5) Come si fa a diventare momentaneamente un altro utente?
Con il comando:
# su utente[ Invio ]
Per riassumere l’identità dell’utente precedente, si dovrà digitare:
# exit[ Invio ]
388.10.6) Come si cambia la propria password?
La propria password si può cambiare con:
# passwd[ Invio ]
388.10.7) Come si cambia la password degli utenti del sistema?
Il comando è:
# passwd utente[ Invio ]43
Si deve ricordare in ogni caso che il comando deve essere impartito dall’utente ‘root’.
388.10.8) Cosa sono le password shadow?
Le password shadow si utilizzano per motivi di sicurezza. Sebbene le password presenti in
‘/etc/passwd’ siano codificate, con gli strumenti necessari e con un po’ di tempo, è possibile risalire alla password originale. L’accesso al file ‘/etc/passwd’ è consentito a tutti gli
utenti. Con le password shadow invece le password vengono mantenute nel file ‘/etc/shadow’,
accessibile solo dall’utente ‘root’.
388.10.9) Come si può evitare la richiesta della password all’avvio?
Per fare ciò, occorre modificare il file che contiene le password44 . Occorrerà cancellare la
password (che appare codificata) relativa all’utente desiderato.
Per esempio, se avessimo un file ‘/etc/passwd’ di questo tipo:
root:Wteoh1TDSchyA:0:0:root:/root:/bin/bash
studente::100:100:,,,:/home/studente:/bin/bash
se si accede al sistema in qualità di utente ‘root’ verrà richiesta la password, mentre non verrà
richiesta accedendo da utente ‘studente’.
388.10.10) Come si può evitare la richiesta del login e della password all’avvio?
Prima di proseguire con la spiegazione, si consiglia innanzitutto di creare un dischetto di avvio
per essere in grado in ogni caso di poter accedere al sistema e poi si devono tenere presenti i
seguenti tre punti:
43
44
utente è l’utente di cui si vuole cambiare la password.
‘/etc/passwd’ o ‘/etc/shadow’.
4484
1. il file ‘/etc/inittab’ contiene le azioni che ‘init’ deve compiere dopo l’avvio del kernel. Viene infatti lanciato ‘mingetty’ o ‘getty’ per effettuare il login ed abilitare i terminali virtuali. Il termine ‘respawn’ (in ‘/etc/inittab’) significa che il processo indicato deve ripartire una volta che è terminato. Ecco perché, impartendo ‘exit’ si ritorna al
prompt del login;
2. la shell Bash, eseguita in modalità login come è spiegato nella LDR 388.9.3, cerca in
successione diversi file di configurazione: ‘/etc/profile’, ‘$HOME/.bash_profile’,
‘$HOME/.bash_login’ e ‘$HOME/.profile’ e se li trova li esegue;
3. normalmente, dopo avere inserito login e password vengono impostate le variabili d’ambiente ‘HOME’, ‘PATH’, ‘SHELL’, ‘TERM’, ‘MAIL’ e ‘LOGNAME’ ed infine viene lanciata la
shell dell’utente specificata in ‘/etc/passwd’. Il normale processo di login quindi, avvia anche l’interprete dei comandi adatto, impostando poi la corretta variabile d’ambiente
‘HOME’. Di conseguenza, saltando il processo di login, la ‘HOME’ rimane impostata a ‘/’, e
non alla directory dell’utente che accede.
Esposte queste tre premesse, ecco come procedere:
1. Si deve modificare il file ‘/etc/profile’:
HOME="/utente"
export HOME
45
.
2. Occorrerà poi modificare il file ‘/etc/inittab’. Le seguenti righe:
# Run gettys in standard runlevels
1:2345:respawn:/sbin/mingetty tty1
# Run xdm in runlevel 5
# xdm is now a separate service
x:5:respawn:/etc/X11/prefdm -nodaemon
dovranno essere modificate e se ne dovranno aggiungere altre due. Il risultato dovrà essere
simile a quanto segue:
#Avvio senza login
1:12345:wait:/bin/bash -login
# Run gettys in standard runlevels
#1:2345:respawn:/sbin/mingetty tty1
# Run xdm in runlevel 5
# xdm is now a separate service
# x:5:respawn:/etc/X11/prefdm -nodaemon
Il termine ‘wait’ significa che si deve aspettare la fine del processo ma questo, una volta
terminato, non sarà riavviato. Infatti, digitando ‘exit’ al prompt, l’interprete dei comandi
si chiuderà e sarà necessario avviare lo spegnimento.
45
questo permetterà di mantenere le configurazioni salvate nella directory home

nanoBase 1997 user manual 4235 This function helps with the

Transcript

Documenti analoghi

Installazione 1

Musiczoom - GnuQuartet

Vademecum del Software - CPIA

dispensa - Linux Day Torino

Emulazione e Virtualizzazione sotto Linux

ULAV (UbuntuLite AntiVirus) - Comune di Campagnano di Roma

HOWTO per installare Knoppix sul vostro Hard disk (Linux Reviews)

Liberiamo il pinguino che si cela nella Vodafone

Linux: distribuzioni e installazione