hellug/magaz
4
1
Fork 0
Κώδικας Ζητήματα Pull requests Έργα Κυκλοφορίες Wiki Δραστηριότητα

Πρώτο commit

Προβολή πηγαίου κώδικα
Αυτό το commit περιλαμβάνεται σε:
infl00p 2022-03-23 20:14:33 +02:00
commit 8ec8e9bee2
451 αρχεία άλλαξαν με 46736 προσθήκες και 0 διαγραφές
Λήψη αρχείου patch Λήψη αρχείου diff Ανάπτυξη όλων των αρχείων Σύμπτυξη όλων των αρχείων

108
content/articles/30/01_editorial.md Κανονικό αρχείο
Προβολή αρχείου

@ -0,0 +1,108 @@
+++
title = 'Editorial'
date = '2001-09-01T00:00:00Z'
description = ''
author = 'Παπαδογιαννάκης Βαγγέλης(mailto:papas@hellug.gr)'
issue = ['Magaz 30']
issue_weight = 1
+++
----------------------------------------------------------------------------------------------------------------------------------------------------------------
*Καλώς ήρθατε στο magaz.*
----------------------------------------------------------------------------------------------------------------------------------------------------------------
**Ενα editorial διαφορετικό από τα άλλα.**
Αυτό το editorial δεν θα σας πει ποια άρθρα φιλοξενούμε αυτό το μήνα, ούτε θα σας προτρέψει να ψηφίσετε σε μια ψηφοφορία. Θα σχολιάσω (όπως το βλέπω εγω) το
περιοδικό μας και μερικά πράγματα για το **linux** ξεχωριστά. Θα μπορούσε να είναι ένα ξεχωριστό άρθρο, αλλά καλά είναι και εδώ, το κάνει πιο επίσημο.
Άλλο ένα καθυστερημένο [magaz](http://magaz.hellug.gr) λοιπόν. Δεν θα προσπαθήσω να δικαιολογηθώ για αυτήν την καθυστέρηση, το ξέρω άλλωστε ότι πολλές ευθύνες
βαραίνουν και εμένα.
Το θέμα είναι ότι κάτι φαίνεται να μην πάει καλά. Τι όμως είναι αυτό, και πώς μπορούμε να το καταπολεμήσουμε, ώστε να μην παίρνω email διαμαρτυρίας για το πότε
θα βγεί το περιοδικό; Και η αλήθεια είναι ότι δεν με πτοούν τα email διαμαρτυρίας. Αυτό που με στεναχωρεί όμως είναι ότι λαμβάνω και πολλά emails με
συγχαρητήρια και προτροπές για να συνεχίσουμε την καλή δουλειά που κάνουμε κ.λπ. Θα απορήσετε γιατί με στεναχωρεί αυτό. Η απάντηση είναι απλή: επειδή βλέπω ότι
δεν είμαστε πια σε θέση να ακολουθήσουμε την ολοένα αυξανόμενη κίνηση των χρηστών υπολογιστών προς το **linux**.
Και εξηγούμαι:\
Είμαστε 5-6 άτομα. Το κάθε περιοδικό απαιτεί 4 άρθρα τουλάχιστον. Αν λοιπόν από αυτά τα 6 άτομα ο ένας δεν μπορέσει ένα μήνα να γράψει άρθρο και αν άλλος ένας
δεν ξέρει τι να γράψει - μια και ο καθένας την ειδικότητά του μερικές φορές την έχει καλύψει και η θεματολογία του πλεον έχει παρουσιαστεί εξολοκλήρου - τότε
πρέπει οι άλλοι να δουλέψουν πυρετωδώς για να βγάλουν ένα περιοδικό για όλους.
Μέχρι πότε; Πόσο πιστεύετε ότι μπορεί να κρατήσει αυτό;
Πόσο δηλαδή κάποιοι θα σηκώνουν όλο το βάρος πάνω τους;
Ξέρω, όλα αυτά είναι χιλιοειπωμένα και στο παρελθόν και η ανταπόκριση ήταν μηδαμινή και τότε. Γιατί τα γράφω λοιπόν; Η απάντηση είναι απλή: επειδή πιστεύω ότι
κάποιοι, έστω και λίγοι, μπορούν (και θέλουν) να βοηθήσουν. Δεν είναι ανάγκη τα άρθρα τους να είναι πλήρη από τεχνικής πλευράς.
Δεν είναι ανάγκη να δουλεύουν και να έχουν φοβερή πείρα, για να γράψουν ένα άρθρο. Δεν είναι ανάγκη να ξέρουν τίποτα παραπάνω από το θέμα για το οποίο θα
γράψουν. Τι θα πει αυτό; Ας πούμε, για παράδειγμα, ότι κάποιος πάει να στήσει την κάρτα ήχου του, τη SB Live!. Γιατί όσο την στήνει να μη γράψει ένα άρθρο με το
οποίο να εξηγεί τι έκανε και δεν πέτυχε, τι έκανε λάθος, τι χρειάστηκε να προσθέσει για να δουλέψει, από που κατέβασε τι κ.λπ.;
Άλλο παράδειγμα: Κάποιος έστησε ένα δικτυάκι στο σπίτι του και χρησιμοποίησε **linux**, για να μοιράζει internet και samba, για file sharing. Γιατί να μη γράψει
και αυτός ένα άρθρο, εξηγώντας πώς το έκανε;
Όπως βλέπετε, δεν είναι ανάγκη να γράφουμε εξειδικευμένα άρθρα. Oι αναγνώστες μας είναι ως επί το πλείστον νέοι. Δεν λέω να μην υπάρχουν τεχνικά άρθρα φυσικά,
αλλά αυτά θα είναι το κερασάκι στην τούρτα.
**Πού απευθύνομαι**; Σε όλους αυτούς που έχουν χρόνο, σε όλους τους φοιτητές που μπορούν να κρατήσουν το περιοδικό ζωντανό. Είναι αυταπόδεικτο ότι δεν μπορούμε
να στηριχτούμε σε άτομα που εργάζονται 8 με 10 ώρες τη μέρα. Είναι λογικό το ότι νέο αίμα πρέπει να κυλίσει. Είναι βασική η βοήθειά σας, μην την αρνιέστε. Χωρίς
όλους εσάς, εμείς δεν μπορούμε να συνεχίσουμε. Μη φοβάστε ότι θα είσαστε λάθος. \`Ολοι είμαστε, λίγο ή πολύ. Η πορεία προς την επιτυχία δεν καθορίζεται από τα
5-6 άτομα τακτικούς αρθρογράφους. Καθορίζεται από το σύνολο των Linuxάδων της χώρας μας.
Αν θέλετε να βοηθήσετε, και δεν ξέρετε πώς, στείλτε ένα email σε εμένα να σας πω λεπτομέρειες. Μη διαβάζετε αυτήν τη γραμμή και μέσα σας λέτε \`\`σιγά μωρέ, ωχ
αδερφέ\'\' και άλλα χαριτωμένα.
Και κάτι τελευταίο και κλείνω αυτόν τον τομέα.\
Το περιοδικό δεν είναι του [hellug](http://www.hellug.gr). Είναι δικό σας. Μπορεί ο [hellug](http://www.hellug.gr) να το φιλοξενεί, αλλά είναι δικό σας! \`Ολων
εσάς που το διαβάζετε κάθε μήνα! Για μια φορά μην το διαβάσετε απλά, βοηθήστε το!
Θα ήθελα, ακόμα, να σχολιάσω το **linux** γενικότερα, παίρνοντας ως αφορμή την ολοένα αυξανόμενη αναλογία του noise/signal στην [Linux Greek
Users](http://lists.hellug.gr).
Η έννοια που πρέπει να καταλάβουν όλοι γύρω από το **linux** , κατά τη δική μου άποψη, δεν είναι ότι είναι τσάμπα (δωρεάν). Δωρεάν προγράμματα υπάρχουν πολλά.
Τσάμπα. Δεν τα πληρώνεις. Δεν είσαι αναγκασμένος να τα πληρώσεις για να τα χρησιμοποιήσεις. Και στα windows υπάρχουν τσάμπα προγράμματα (**IE, outlook express,
realdownload**, κα). Το θέμα είναι ο κώδικας.
Είναι η ελευθερία που σου παρέχει να **ΔΕΙΣ** πώς αυτό το πρόγραμμα κάνει αυτό που κάνει. Να σιγουρευτείς ότι δεν έχει ένα **backdoor**, ούτε στέλνει τα
στοιχεία σου σε έναν κεντρικό server και **φακελώνεσαι κανονικά και με το νόμο**. \`Ολοι έχουν ακούσει για τα περίφημα *\`\`τσάμπα\'\'* προγράμματα που στέλνουν
σε ένα server τα αρχεία που κατεβάζεις, τις σελίδες που επισκέπτεσαι, το όνομα και το επώνυμό σου. Η πιο τρανή απόδειξη είναι το **RealDownload** και όλα τα
προγράμματα της ABE (ναι, και το **CuteFTP** που όλοι χρησιμοποιείτε).\
Σας παραπέμπω στις εξής σελίδες:
<http://www.donkboy.com/html/brother.htm>\
<http://grc.com/downloaders.htm>
όπου μπορείτε να δείτε πώς οι κύριοι που βγάζουν \`\`τσάμπα\'\' προγράμματα σας φακελώνουν κανονικά, τόσο εσάς όσο και τις προτιμήσεις σας, τις σελίδες που
επισκέπτεστε, όλα.
Κάτι τέτοιο με προγράμματα του **linux** είναι απίθανο (αδύνατο) να συμβεί, μια και η συντριπτική πλειοψηφία είναι OPEN SOURCE, (παρέχεται και ο κώδικας). Αν
κάποιος αντιληφθεί κάτι τέτοιο, είναι θέμα ωρών να διορθωθεί το πρόβλημα και να κατέβει αυτό το πρόγραμμα από οπουδήποτε υπάρχει.
Αυτό είναι το καλό του **linux**. \`Οχι ότι είναι \`\`τσάμπα\'\'.
Μαζί, φυσικά, έρχονται και κάτι άλλα, που λίγοι τα εκτιμούν. Είναι η δημιουργία (και τήρηση) των standards (έχετε δοκιμάσει reverse DNS se NT;). Είναι ότι άν
βρεθεί τρύπα ασφαλείας, σε μία ώρα έχει φτιαχτεί. Είναι ότι η βελτίωση είναι ραγδαία, ακόμα και στο επίπεδο του desktop, που ενδιαφέρει τους περισσότερους
(νέους) χρήστες (σας θυμίζω την περίπτωση του \`\`πολυσυζητημένου\'\' benchmark win2K-Linux, όπου υπήρχε ένα λάθος στο TCP stack του πυρήνα. Φτιάχτηκε σε
λιγότερο από 1 ώρα).
Είναι όλα αυτά που κάνουν το λειτουργικό μας ξεχωριστό. Είναι όλα αυτά που μας κάνουνε να λατρέυουμε το **linux**. Και συγχωρέστε μας, αν καμιά φορά είμαστε
απότομοι, είναι όμως \*σκληρό\* να βλέπεις πόσοι πολλοί δεν κάνουν το βασικότερο, να διαβάσουν το help. Απαιτούν κάτι έτοιμο, κάτι μασημένο. Αυτούς δεν τους
θέλουμε. Θέλουμε σκεπτόμενα άτομα, θέλουμε άτομα ενεργά και όχι παράσιτα. Θέλουμε βοήθεια, όπως εμείς προσφέρουμε βοήθεια. Δεν θέλουμε τα script kiddies, τους
ετοιματζήδες, δεν θέλουμε τους (και καλά) hackers. Ποιους (και καλά) hackers; Θα σας δώσω ένα παράδειγμα.
Αυτούς που θέλουν να hackέψουν **linux** servers με το Unicode Bug! Που θέλουν να κατεβάσουν ένα μηχάνημα, για να το λένε αργότερα κομπάζοντας στα φιλαράκια
τους, αλλά ούτε καν κάνουν τον κόπο να δούνε τι λειτουργικό τρέχει! Υπάρχουν web servers, που δέχονται γύρω στις 20 επιθέσεις τη μέρα, και οι 18 είναι με χρήση
του **Unicode Bug**, bugs του **FrontPage** και bugs του **IIS** (και των samples αυτού). Αν αυτοί δεν είναι παιδάκια που θέλουν να κάνουν το κομμάτι τους, τι
είναι;
Αυτά είχα να πω, να ξανατονίσω όμως ότι είναι προσωπικές μου απόψεις, και δεν έχουν καμία σχέση με το [magaz](http://magaz.hellug.gr) ή το
[hellug](http://www.hellug.gr) γενικότερα. Οποιοδήποτε flame/αντίρρηση/παρατηρήσεις/συγχαρίκια/email με vbscript viruses(!) , στείλτε τα στο
[papas\@hellug.gr](papas@hellug.gr). Βεβαιωθείτε μόνο ότι έχετε βάλει charset, αν υπάρχουν ελληνικά, γιατί το **procmail** μου δεν αστειεύεται (BTW, υπάρχει ένα
πολύ καλό άρθρο για το procmail αυτό το μήνα από τον Αποστολάκη Νίκο)
Κλείνοντας, να ζητήσω συγνώμη από τα άτομα που μου έχουν στείλει άρθρο πολύ καιρό αλλά λόγω της έλλειψης ύλης δεν μπορούσα να τα δημοσιεύσω.
[Παπαδογιαννάκης Βαγγέλης](mailto:papas@hellug.gr)

386
content/articles/30/02_xbasic.md Κανονικό αρχείο
Προβολή αρχείου

@ -0,0 +1,386 @@
+++
title = 'Xbasic'
date = '2001-09-01T00:00:00Z'
description = ''
author = 'Κώστας Τσακάλογλου(mailto:tsakf@hellug.gr)'
issue = ['Magaz 30']
issue_weight = 2
+++
----------------------------------------------------------------------------------------------------------------------------------------------------------------
*Εντολές ανακύκλωσης*
----------------------------------------------------------------------------------------------------------------------------------------------------------------
**1. Εντολές ανακύκλωσης**
---------------------------------------------------
**2. Η εντολή FOR \... NEXT**
------------------------------------------------------
- [2.1 Παράδειγμα](#ss2.1)
**3. FOR \... NEXT μέσα σε άλλο FOR..NEXT**
--------------------------------------------------------------------
- [3.1 Παράδειγμα πολλαπλών FOR\...NEXT.](#ss3.1)
**4. Η εντολή EXIT FOR**
-------------------------------------------------
### [1. Εντολές ανακύκλωσης]{#s1}
Ο τρόπος που εκτελείται ένα πρόγραμμα XBASIC είναι ο συνηθισμένος, όπου οι εντολές εκτελούνται από επάνω προς τα κάτω.\
Η εκτέλεση των εντολών ξεκινά από την συνάρτηση `ENTRY()` και εκτελούνται μία-μία οι εντολές, από επάνω προς τα κάτω μέχρι να φτάσουμε στην εντολή
`END FUNCTION` όπου εκεί τελειώνει η εκτέλεση του προγράμματος.
Στην πραγματικότητα όμως, σπάνια βρίσκουμε προγράμματα που να εκτελούνται έτσι απλά όπως περιγράψαμε πριν. Σε πάρα πολλές περιπτώσεις χρειαζόμαστε
επαναλαμβανόμενες διαδικασίες και πολύπλοκους ελέγχους για να κατασκευάσουμε ένα πρόγραμμα που θα εκτελεί κάποια ζητούμενη, σύνθετη εργασία.\
Η XBASIC μας δίνει κάποιες εντολές για να μπορούμε να έχουμε επαναλαμβανόμενες διαδικασίες μέσα στο πρόγραμμά μας. Αυτές είναι οι εντολές `FOR ... NEXT` και η
εντολές `DO ... LOOP`
Παρακάτω θα αναλύσουμε και τις δύο για να δούμε την χρήση τους και πως μπορούμε να τις εφαρμόσουμε.
### [2. Η εντολή FOR \... NEXT]{#s2}
Αυτή την εντολή την χρησιμοποιούμε για να έχουμε την εκτέλεση μιας ή μιας ομάδας εντολών για προκαθορισμένο αριθμό επαναλήψεων. Η μορφή της είναι:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
FOR [μεταβλητή] = [αρχική τιμή] ΤΟ [τελική τιμή] STEP [βήμα]
..
[εντολές που θα εκτελεστούν επαναλαμβανόμενα]
..
NEXT [μεταβλητή]
----------------------------------------------------------------------------------------------------------------------------------------------------------------
### [2.1 Παράδειγμα]{#ss2.1}
Θα δούμε ένα παράδειγμα χρήσης της FOR \... NEXT
----------------------------------------------------------------------------------------------------------------------------------------------------------------
1. '
2. '
3. ' ####################
4. ' ##### PROLOG #####
5. ' ####################
6. '
7. PROGRAM "progname" ' 1-8 char program/file name without .x or any .extent
8. VERSION "0.0000" ' version number - increment before saving altered program
9. '
10. ' You can stop the PDE from inserting the following PROLOG comment lines
11. ' by removing them from the prolog.xxx file in your \xb\xxx directory.
12. '
13. ' Programs contain: 1: PROLOG - no executable code - see below
14. ' 2: Entry function - start execution at 1st declared func
15. ' * = optional 3: Other functions - everything else - all other functions
16. '
17. ' The PROLOG contains (in this order):
18. ' * 1. Program name statement PROGRAM "progname"
19. ' * 2. Version number statement VERSION "0.0000"
20. ' * 3. Import library statements IMPORT "libName"
21. ' * 4. Composite type definitions TYPE <typename> ... END TYPE
22. ' 5. Internal function declarations DECLARE/INTERNAL FUNCTION Func (args)
23. ' * 6. External function declarations EXTERNAL FUNCTION FuncName (args)
24. ' * 7. Shared constant definitions $$ConstantName = literal or constant
25. ' * 8. Shared variable declarations SHARED variable
26. '
27. ' ****** Comment libraries in/out as needed *****
28. '
29. ' IMPORT "xma" ' Math library : SIN/ASIN/SINH/ASINH/LOG/EXP/SQRT...
30. ' IMPORT "xcm" ' Complex library : complex number library (trig, etc)
31. ' IMPORT "xst" ' Standard library : required by most programs
32. ' IMPORT "xgr" ' GraphicsDesigner : required by GuiDesigner programs
33. ' IMPORT "xui" ' GuiDesigner : required by GuiDesigner programs
34. '
35. DECLARE FUNCTION Entry ()
36. '
37. '
38. ' ######################
39. ' ##### Entry () #####
40. ' ######################
41. '
42. ' Programs contain:
43. ' 1. A PROLOG with type/function/constant declarations.
44. ' 2. This Entry() function where execution begins.
45. ' 3. Zero or more additional functions.
46. '
47. FUNCTION Entry ()
48. SSHORT i
49. FOR i=1 TO 20
50. PRINT i
51. NEXT i
52. END FUNCTION
53. END PROGRAM
----------------------------------------------------------------------------------------------------------------------------------------------------------------
#### Γραμμές 1..35 Ορισμοί
Οι γνωστές πια σε όλους γραμμές ορισμού του προγράμματος των βιλιοθηκών και των συναρτήσεων του προράμματος.
#### Γραμμές 47..52 Η συνάρτηση ENTRY()
Εδώ έχουμε την συνάρτηση `ENTRY()` όπου και θα αναλύσουμε για να δούμε τον τρόπο λειτουργίας της `FOR ... NEXT`
Η εκτέλεση του προγράμματος ξεκινά από την γραμμή 49 όπου υπάρχει και η εντολή `FOR`. Έχοντας ορίσει ακριβώς παραπάνω το είδος της μεταβλητής `i` μπορούμε να
την χρησιμοποιήσουμε. Αναφέρω ξανά τα παραπάνω προασμοσμένα στο παράδειγμά μας.
----------------------------------------------------------------------------------------------------------------------------------------------------------------
FOR [μεταβλητή] = [αρχική τιμή] ΤΟ [τελική τιμή] STEP [βήμα]
..
[εντολές που θα εκτελεστούν επαναλαμβανόμενα]
..
NEXT [μεταβλητή]
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Όπου έχουμε :\
----------------------------------------------------------------------------------------------------------------------------------------------------------------
[μεταβλητή] = i
[αρχική τιμή] = 1
[τελική τιμή] =20
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Το `STEP` έχει παραλειφθεί γιατί θεωρείται ότι η απουσία της STEP δηλώνει αύξηση κατά 1
----------------------------------------------------------------------------------------------------------------------------------------------------------------
[εντολές που θα εκτελεστούν επαναλαμβανόμενα]= PRINT i
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Θα ξεκινήσουμε παρακολουθώντας βήμα-βήμα την εκτέλεση του προγράμματος για να δούμε τι γίνεται.
Η εκτέλεση ξεκινά από την γραμμή 49 όπου η μεταβλητή `i` παίρνει την τιμή `1` και γίνεται έλεγχος άν αυτή η τιμή είναι μεγαλύτερη από την τελική τιμή της. Εφ\'
όσον η τιμή της μεταβλητής είναι μικρότερη από την τελική τιμή, τότε συνεχίζεται η εκτέλεση της γραμμής 50.\
Στην γραμμή 50 γίνεται εμφάνιση της τιμής της `i` στο παράθυρο κοσόλας της **XBASIC**. Στην γραμμή 51 γίνεται αύξηση της τιμής της `i` κατά το βήμα που έχει
ορισθεί (1) και εκτελείται ξανά η εντολή 49. Τώρα πάλι γίνεται έλεγχος άν η τιμή της `i` που είναι πια 2 είναι μικρότερη από την μέγιστη (20). Είναι, οπότε
έχουμε πάλι την εκτέλεση της γραμμής 50 και εμφανίζεται πάλι στο παράθυρο κονσόλας η τιμή της i. Συνεχίζουμε ξανά με την ΝΕΧΤ όπου η τιμή της i γίνεται 3. Πάλι
εκτέλεση της 49, έλεγχος και επανάληψη όλων των παραπάνω μέχρι η τιμή της `i` να γίνει 20.\
Μόλις η τιμή γίνει 20 τότε ο έλεγχος στην γραμμή 49 δίνει ότι έχουμε φτάσει στην τελική τιμή της μεταβλητής. Τότε παταλείπονται όλες οι εντολές μέχρι την εντολή
`NEXT` και η εκτέλεση του προγράμματος συνεχίζεται μετά από αυτήν. Στο παράδειγμά μας, δεν έχουμε τίποτε άλλο έτσι η εκτέλεση του προγράμματος τελειώνει.
Με την βοήθεια ορισμού του βήματος μπορούμε να έχουμε διάφορες περιπτώσεις που η μεταβλητή `i` δεν αυξάνει κατά 1 αλλά με διαφορετικό βήμα. Π.χ.
----------------------------------------------------------------------------------------------------------------------------------------------------------------
FOR i= 1 to 16 STEP 3
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Σε αυτή την περίπτωση το βήμα για κάθε ανακύκλωση αυξάνει κατά 3 και οι διαδοχικές τιμές που μπορεί λαμβάνει η `i` είναι 1,4,7,10,13,16. Επίσης μπορούμε να
έχουμε αντί για αύξηση της τιμής της `i` μείωση με την παρακάτω σύνταξη.
----------------------------------------------------------------------------------------------------------------------------------------------------------------
FOR i = 16 to 1 STEP -1
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Σε αυτή την περίπτωση η διαδοχικές τιμές της `i` θα είναι 16,15,14,\...3,2,1.
Συνοψίζοντας βλέπουμε ότι με την εντολή `FOR ... NEXT` μπορούμε να έχουμε επαναλαμβανόμενη εκτέλεση κώδικα όσες φορές επιθυμούμε
και με οποιοδήποτε βήμα.
### [3. FOR \... NEXT μέσα σε άλλο FOR..NEXT]{#s3}
Υπάρχει η δυνατότητα να έχουμε πολλαπλά `FOR ... ΝΕΧΤ` το ένα μέσα στο άλλο.\
Απαραίτητη προυπόθεση είναι αυτά να έχουν διαφορετικές μεταβλητές μέτρησης. Αν χρησιμοποιηθεί η ίδια μεταβλητή μέτρησης τότε το ένα `NEXT` θα επηρεάζει το άλλο
με απρόβλεπτα αποτελέσματα στην εκτέλεση του κώδικα.\
Έτσι είναι λάθος να γράψουμε:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
FOR i=1 TO 10
FOR i=2 TO 7
.
.
.
NEXT i
NEXT i
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Θα παρατηρήσουμε ότι στο παραπάνω παράδειγμα έχει τοποθετηθεί το δεύτερο `FOR` δεξιότερα από το πρώτο.\
Αυτό μας βοηθάει πάρα πολύ κατά την ανάγνωση το προγράμματός μας να βλέπουμε που τελειώνει η κάθε ανακύκλωση χωριστά. Ένα άλλο λάθος που γίνεται μερικές φορές
είναι η λάθος αντιστοίχηση των `FOR` με τα αντίστοιχα `NEXT`. Κάποιος που θα γράψει:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
FOR i= 1 TO 10
FOR k= 1 TO 5
.
.
.
NEXT i
NEXT k
----------------------------------------------------------------------------------------------------------------------------------------------------------------
θα λάβει μήνυμα λάθους `NESTING ERROR`. Αυτό συμβαίνει γιατί κατά την ανάγνωση του κώδικα ο υπολογιστής έχει καταχωρίσει ότι η τελευταία μεταβλητή μέτρησης
είναι η `k` και όχι η `i`.
Ένα άλλο λάθος που μπορεί να γίνει είναι ο λάθος υπολογισμός της τελικής τιμής άν έχουμε βήμα διαφορετικό από το 1 όπως στο προηγούμενο παράδειγμα και έτσι ενώ
έχουμε γράψει
----------------------------------------------------------------------------------------------------------------------------------------------------------------
FOR i = 1 TO 10 STEP 3
.
.
ΝΕΧΤ i
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Ετσι η τελική τιμή της μεταβλητής i είναι διαφορετική από αυτήν που περιμένουμε να έχει η i κατά την τελευταία ανακύκλωση.
### [3.1 Παράδειγμα πολλαπλών FOR\...NEXT.]{#ss3.1}
Θα γράψουμε ένα μικρό πρόγραμμα που θα δημιουργεί μια επιφάνεια από Χ ανάλογα με τις διαστάσεις που εισάγουμε.
----------------------------------------------------------------------------------------------------------------------------------------------------------------
1. '
2. '
3. ' ####################
4. ' ##### PROLOG #####
5. ' ####################
6. '
7. PROGRAM "progname" ' 1-8 char program/file name without .x or any .extent
8. VERSION "0.0000" ' version number - increment before saving altered program
9. '
10. ' You can stop the PDE from inserting the following PROLOG comment lines
11. ' by removing them from the prolog.xxx file in your \xb\xxx directory.
12. '
13. ' Programs contain: 1: PROLOG - no executable code - see below
14. ' 2: Entry function - start execution at 1st declared func
15. ' * = optional 3: Other functions - everything else - all other functions
16. '
17. ' The PROLOG contains (in this order):
18. ' * 1. Program name statement PROGRAM "progname"
19. ' * 2. Version number statement VERSION "0.0000"
20. ' * 3. Import library statements IMPORT "libName"
21. ' * 4. Composite type definitions TYPE <typename> ... END TYPE
22. ' 5. Internal function declarations DECLARE/INTERNAL FUNCTION Func (args)
23. ' * 6. External function declarations EXTERNAL FUNCTION FuncName (args)
24. ' * 7. Shared constant definitions $$ConstantName = literal or constant
25. ' * 8. Shared variable declarations SHARED variable
26. '
27. ' ****** Comment libraries in/out as needed *****
28. '
29. ' IMPORT "xma" ' Math library : SIN/ASIN/SINH/ASINH/LOG/EXP/SQRT...
30. ' IMPORT "xcm" ' Complex library : complex number library (trig, etc)
31. ' IMPORT "xst" ' Standard library : required by most programs
32. ' IMPORT "xgr" ' GraphicsDesigner : required by GuiDesigner programs
33. ' IMPORT "xui" ' GuiDesigner : required by GuiDesigner programs
34. '
35. DECLARE FUNCTION Entry ()
36. '
37. '
38. ' ######################
39. ' ##### Entry () #####
40. ' ######################
41. '
42. ' Programs contain:
43. ' 1. A PROLOG with type/function/constant declarations.
44. ' 2. This Entry() function where execution begins.
45. ' 3. Zero or more additional functions.
46. '
47. FUNCTION Entry ()
48. USHORT i1,i2
49. USHORT side1,side2
50. STRING sside1,sside2
51. sside1=INLINE$("side 1 ")
52. sside2=INLINE$("side 2 ")
53. side1=USHORT(sside1)
54. side2=USHORT(sside2)
55. FOR i1 = 1 TO side1
56. FOR i2 = 1 TO side2
57. PRINT "X";
58. NEXT i2
59. PRINT ""
60. NEXT i1
61.
62.
63.
64. END FUNCTION
65. END PROGRAM
----------------------------------------------------------------------------------------------------------------------------------------------------------------
#### Γραμμές 1..46
Οι ορισμοί του προγράμματος και των βιβλιοθηκών που χρειάζονται
#### Γραμμές 47..64
Η συνάρτηση `ENTRY()` που περιέχει και τον εκτελέσιμο κώδικα του προγράμματός μας.
Θα αναλύσουμε την `ENTRY()` για να δούμε την διαδοχική χρήση των εντολών `FOR ... NEXT`
#### Γραμμή 48
Σε αυτές τις γραμμές ορίζουμε τις μεταβλητές που θα χρησιμοποιήσουμε παρακάτω στις εντολές `FOR ... NEXT`
#### Γραμμή 49
Ορίζονται οι μεταβλητές που θα περιεχουν τις διαστάσεις της τετράγωνης επιφάνειας.
#### Γραμμή 50
Εδώ ορίζουμε βοηθητικές μεταβλητές τύπου STRING για να πάρουμε την πληκτρολόγηση του χρήστη.
#### Γραμμές 51 και 52
Με την γνωστή πια εντολή `INLINE$` δίνουμε μήνυμα στον χρήστη να εισάγει διαδοχική τις επιθυμιτές διαστάσεις του τετραγώνου.
#### Γραμμές 53 και 54
Μετατροπή των μεταβλητών STRING σε αριθμητικές για να τις χρησιμοποιήσουμε παρακάτω και τις εντολές ανακύκλωσης `FOR ... NEXT`
#### Γραμμή 55
Αρχή της πρώτης ανακύκλωσης. Εδώ ο μετρητής `i1` θα λάβει τιμές από 1 έως την τιμή της μεταβλητής `side1` που είναι η κάθετη διάσταση του τετραγώνου
#### Γραμμή 56
Αρχή της δεύτερης ανακύκλωσης. Εδώ ο `i2` θα λάβει τιμές από 1 έως την τιμή της `side2` που είναι η οριζόντια διάσταση του τετραγώνου.
#### Γραμμή 57
Εμφάνιση στο παράθυρο κονσόλας του χαρακτήρα `X`
#### Γραμμή 58
Κλείσιμο της δεύτερης ανακύκλωσης και έτσι η εκτύπωση των `X` θα γίνει τόσες φορές όσες έχει επιλέξει ο χρήστης που έχουν αποθηκευθεί στην μεταβλητή `side2`
#### Γραμμή 59
Αλλαγή γραμμής στο παράθυρο κονσόλας.
#### Γραμμή 60
Κλείσιμο της πρώτης ανακύκλωσης. Εδώ τών αυξάνει κατά 1 ο μετρητής της κάθετης διάστασης του τετραγώνου. Ετσι ολόκληρη η διαδικασία \[επαναλαμβανόμενη εμφάνισης
των `X` (δεύτερη ανακύκλωση) και η αλλαγή γραμμής\] θα γίνει τόσες φορές όσες έχει ζητήσει ο χρήστης όταν όριζε την πρώτη (κάθετη) διάσταση του τετραγώνου. Αυτή
η τιμή είναι αποθηκευμένη στην μεταβλητή `side1`.
### [4. Η εντολή EXIT FOR]{#s4}
Συνήθως χρησιμοποιούμε τις ανακυλώσεις για να εκτελέσουμε συγκεκριμένο αριθμό επαναλήψεων ενός κομματιού κώδικα.\
Υπάρχουν όμως περιπτώσεις που θέλουμε να διακόψουμε την ανακύκλωση στην μέση γιατί μετά από κάποιο έλεγχο που κάνουμε, θέλουμε να συνεχίσει το πρόγραμμα με τον
κώδικα που υπάρχει μετά το `NEXT`. Τότε μαζί με τον έλεγχό μας χρησιμοποιούμε και την εντολή `EXIT FOR` έτσι το `FOR ... NEXT`
διακόπτεται και η εκτέλεση συνεχίζεται μετά το `NEXT` σαν να είχε τελειώσει κανονικά η ανακύκλωση.

325
content/articles/30/03_yacas.md Κανονικό αρχείο
Προβολή αρχείου

@ -0,0 +1,325 @@
+++
title = 'YACAS (Yet Another Computer Algebra System)'
date = '2001-09-01T00:00:00Z'
description = ''
author = 'Πίπιλας Κων/νος(mailto:pilotos@hellug.gr)'
issue = ['Magaz 30']
issue_weight = 3
+++
**1. ΕΙΣΑΓΩΓΗ**
---------------------------------------
**2. ΕΓΚΑΤΑΣΤΑΣΗ**
------------------------------------------
**3. ΧΡΗΣΗ**
------------------------------------
**4. ΕΠΙΠΛΕΟΝ ΣΤΟΙΧΕΙΑ**
------------------------------------------------
**5. Yacas vs Others**
----------------------------------------------
### [1. ΕΙΣΑΓΩΓΗ]{#s1}
Πρόκειται για ένα πολύ ισχυρό και επεκτάσιμο πρόγραμμα, που για να εκμεταλευτείτε όλη του τη δύναμη \"θα πρέπει να του μιλήσετε στη δική του γλώσσα\". Δεν είναι
και τίποτα ιδιαίτερο, ιδίως αν έχετε μια βασική γνώση προγραμματισμού. Αλλά και εντελώς αρχάριοι να είστε, νομίζω ότι είναι απλά θέμα εξοικείωσης και λίγων
λεπτών για να μπορέσετε να κάνετε τις βασικές εργασίες.
Αν λοιπόν θέλετε να εκτελείτε σε δευτερόλεπτα διάφορα προβλήματα όπως υπολογισμός παραγώγου, ολοκληρωμάτων, ορίων, πολλαπλασιασμός πινάκων, επίλυση γραμμικών
εξισώσεων, απλοποίηση παραστάσεων, υπολογισμός σειρών Taylor κτλ., που απαιτούν ένα σωρό πράξεις σίγουρα το Yacas θα το αγαπήσετε.
### [2. ΕΓΚΑΤΑΣΤΑΣΗ]{#s2}
Το Yacas μπορείτε να το κατεβάσετε από το επίσημο site:\
url name=\"http://www.xs4all.nl/ apinkus/\" url=\"http://www.xs4all.nl/ apinkus/\"\>\
ή από κάποιο κοντινό mirror\
(http://linuxberg.ntua.gr στο Ε.Μ.Π. στην κατηγορία X11/Scientific/Math/).\
Το μέγεθος του είναι περίπου 450ΚΒ.
Είναι συμβατό με όλες τις Unixοειδή πλατφόρμες (αφού η είσοδος και η έξοδος του Yast είναι σε μορφή text) οπως τα **Linux**, **FreeBSD** κτλ., αρκεί να έχετε
εγκατεστημένο ένα compiler **C++**, πχ. **τον g++**.
Αφού το κατεβάσετε εκτελέστε την εντολή :
----------------------------------------------------------------------------------------------------------------------------------------------------------------
tar -xzvf yacas-έκδοση.tgz
----------------------------------------------------------------------------------------------------------------------------------------------------------------
στον κατάλογο που επιθυμείτε. Στην συνέχεια μπείτε σε αυτόν τον κατάλογο και πληκτρολογήστε τις εξής εντολές :
----------------------------------------------------------------------------------------------------------------------------------------------------------------
./configure
make
make install
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Αν όλα πάνε καλά τότε είστε έτοιμοι να χρησιμοποιήσετε το πρόγραμμα με την εντολή yacas. Εκτός από τη **Source** μορφή, μπορείτε να το κατεβάσετε και σε **RPM ή
DEB**.
### [3. ΧΡΗΣΗ]{#s3}
Για να ξεκινήσει το Yacas όπως είπαμε και πιο πάνω γράψτε
----------------------------------------------------------------------------------------------------------------------------------------------------------------
yacas
----------------------------------------------------------------------------------------------------------------------------------------------------------------
ή αν είστε στα X-Windows ανοίξτε ένα παράθυρο προσωμοίωσης τερματικού και κάντε το ίδιο. Στις πρώτες σειρές θα δείτε κάποιες πληροφορίες για το πρόγραμμα και
την βοήθεια. Στην συνέχεια βλέπετε το command prompt του Yacas:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
In>
----------------------------------------------------------------------------------------------------------------------------------------------------------------
στο οποίο εισάγετε όλες τις εντολές.Στο τέλος κάθε εντολής μπαίνει ένα ελληνικό ερωτηματικό. Σε κάθε γραμμή μπορείτε να εισάγετε μια μόνο εντολή.Πχ:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
In>N(Cos(Pi));
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Οι \`\`απαντήσεις\'\' του Yacas στις εντολές που του δίνουμε εμφανίζονται μετά το prompt:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Out>
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Για να κλείσουμε το πρόγραμμα πληκτρολογούμε `Exit()` ή `quit` ή `^C (Ctrl+C)`.
Το Yacas συνοδεύεται από ένα πολύ καλό documentation, που εξηγούνται όλες οι λεπτομέρειες του προγράμματος και η πρόσβαση σ\' αυτό γίνεται με την εντολή `??`
όπου και θα ανοίξει ο Browser **Lynx** για να δείτε τις **HTML** σελίδες του documentation. Επίσης μπορείτε να πάρετε βοήθεια για μια συνάρτηση δίνοντας
`?συνάρτηση()`, πχ.
----------------------------------------------------------------------------------------------------------------------------------------------------------------
?Sin()
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Το συντακτικό που χρησιμοποιεί το Yacas είναι C-like.\
Δηλαδή οι αριθμητικές πράξεις παριστάνονται ως εξής:
πρόσθεση : +\
αφαίρεση : -\
πολ/σμος : \*\
διαίρεση : /\
δύναμη : \^ (δηλαδή το 2 στον κύβο παριστάνεται 2\^3).
Δύο άλλα σύμβολα που χρησιμοποιούνται είναι:\
ανάθεση τιμής : =\
ισότητα : ==
Επίσης υπάρχουν διάφορες συναρτήσεις εκ των οποίων οι βασικότερες είναι οι:\
ημίτονο = `Sin()`\
συνημίτονο = `Cos()`\
εφαπτομένη = `Tan()`\
Υπολογισμός `e^x = Exp(x)`\
νεπέριος λογάριθμος του `x = Ln(x)`\
ρίζα του `x=Sqrt(x)`\
απόλυτη τιμή αριθμού = `Abs(x)`\
η αριθμητική τιμή μιας έκφρασης = `N(έκφραση)`\
n παραγοντικό = `n!`
Για μια ολοκληρωμένη εικόνα των συναρτήσεων που συναντούνται στο Yacas υπάρχει το **functions reference** (το βρίσκετε με την εντολή `??`). Για παράδειγμα ένας
αριθμητικός υπολογισμός που θα μπορούσε να εκτελεστεί στο Yacas θα ήταν:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
In>(3*6^2+7*897)/(N(Sin(5)*Tan(6)));
----------------------------------------------------------------------------------------------------------------------------------------------------------------
και η έξοδος από το Yacas θα ήταν :
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Out>22888.1333231108;
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Όταν δουλεύουμε με δεκαδικούς αριθμούς τότε μπορούμε από την αρχή να καθορίσουμε την ακρίβεια των δεκαδικών ψηφίων.\
Αυτό γίνεται με την συνάρτηση `Precision(n)`, όπου n ο αριθμός των δεκαδικών ψηφίων. Πχ.:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
In> Precision(15);
Out> True;
In> N(7/23);
Out> 0.304347826086956;
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Το κύριο χαρακτηριστικό του Yacas είναι η χρήση λιστών για την παρουσίαση πιο σύνθετων αλγορίθμων όπως ο πολ/σμος πινάκων, διανυσμάτων κτλ. (η ιδέα αυτή
προέρχεται από την γλώσσα προγραμματισμού LISP).\
Μια λίστα είναι ένα αριθμημένο σύνολο από αντικείμενα. Στο Yacas μια λίστα δημιουργείται βάζοντας μέσα σε άγκυστρα τα αντικείμενα και χωρίζοντάς τα με κώμμα.
Πχ. αν `a, b, c, d` είναι αντικείμενα, μια λίστα θα είχε τη μορφή : {a,b,c,d}. Έτσι ένα διάνυσμα παριστάνεται στο Yacas σαν μια λίστα και ένας πίνακας σαν μια
λίστα από λίστες. Για να προσπελάσουμε ένα αντικείμενο μιας λίστας χρησιμοποιούμε την εντολή: `ls[n]`, όπου `ls` είναι το όνομα της λίστας και `n` είναι η θέση
του αντικειμένου που ζητάμε από τη λίστα. Οπότε αν είχαμε το διάνυσμα
----------------------------------------------------------------------------------------------------------------------------------------------------------------
ls{a,b,c,d,e,f}
----------------------------------------------------------------------------------------------------------------------------------------------------------------
τότε θα μπορούσαμε να εκτελέσουμε τις εξής εντολές:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
ls[3];
----------------------------------------------------------------------------------------------------------------------------------------------------------------
και η έξοδος του προγράμματος θα ήταν το `c`.
----------------------------------------------------------------------------------------------------------------------------------------------------------------
ls[2 .. 4];
----------------------------------------------------------------------------------------------------------------------------------------------------------------
και η έξοδος θα ήταν η λίστα `{b,c,d}` (οι 2 τελείες \"..\" μεταφράζονται \"εως\" και χρησιμοποιούνται για λόγους συντομίας). Ας κάνουμε τώρα ενα παράδειγμα
πολ/σμού πινάκων. Έστω ο πίνακας Κ23 είναι 2x3 και ο M34 είναι 3x4. Για να τους ορίσουμε δίνουμε στο prompt:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
In> K23:={{x,y,2},{4,y,x)}; και
In> M34:={{3,x,y,x+1},{x+y,y-2,2,y},{y^2-1,4,y,2*x^2}};
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Οπότε αν τώρα δώσουμε
----------------------------------------------------------------------------------------------------------------------------------------------------------------
K23*M34
----------------------------------------------------------------------------------------------------------------------------------------------------------------
θα πάρουμε το γινόμενο των 2 αυτών πινάκων που είναι ένας νέος πίνακας 2x4.
Υπάρχουν αρκετές συναρτήσεις για τους πίνακες και γενικά για την γραμμική 'λγεβρα όπως η συνάρτηση `Determinant(M)`, που μας επιστρέφει την ορίζουσα του πίνακα
M, η `Inverse(Μ)` που επιστρέφει τον αντίστροφο του M κτλ.
Στο **Yacas** μπορούμε να δουλέψουμε άνετα με συναρτήσεις και να κάνουμε τους συνήθεις υπολογισμούς όπως υπολογισμός τιμών συνάρτησης, παραγώγου, ολοκληρώματος
και ορίου.\
Πχ. έστω ότι έχουμε την συνάρτηση `f(x)=2x+3` και θέλουμε να υπολογίσουμε το `f(4)`, την παράγωγο της `f`,το ολοκλήρωμα της `f` από `a` εως `b` και το όριο της
`f` όταν το `x` τείνει στο 0. Τότε θα είχαμε τα παρακάτω :
----------------------------------------------------------------------------------------------------------------------------------------------------------------
In> f(x):=2*x+3; /* Ορισμός συνάρτησης */
Out> true;
In>f(4); /* Υπολογισμός του f(4) */
Out>11;
In>D(x) f(x); /* Υπολογισμός παραγώγου της f */
Out>2;
In>Integrate(x,a,b) f(x); /* Υπολογισμός ολοκληρώματος */
Out>(2*b^2)/2+3*b-((2*a^2)/2+3*a);
In>Limit(x,0) f(x); /* Υπολογισμός ορίου της f όταν x->0 */
Out>3;
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Με το Yacas έχουμε την δυνατότητα επίλυσης συστημάτων γραμμικών (προς το παρόν) εξισώσεων, αρκεί να μην το παρακάνετε (μην του βάλετε ένα σύστημα 100x100 γιατί
θα σας πάρει κάποια χρόνια:).
Για παράδειγμα έστω ότι θέλουμε να λύσουμε το σύστημα :
----------------------------------------------------------------------------------------------------------------------------------------------------------------
4x+6y+z=2
x-4z=4
y+2z=2
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Θα χρησιμοποιήσουμε την συνάρτηση `Solve` πέρνωντας κάθε εξίσωση και κάθε μεταβλητή σαν στοιχεία μιας λίστας :
----------------------------------------------------------------------------------------------------------------------------------------------------------------
In> Solve({4*x+6*y+z==2,x-4*z==4,y+2*z==2},{x,y,z});
Out> {{-84/5,62/5,-26/5}};
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Μπορούμε ακόμη να κάνουμε απλοποίηση παραστάσεων με την συνάρτηση `Simplify`:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
In> Simplify((x-8)^2+(x-6)^2);
Out> 2*x^2-28*x+100;
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Πολλές φορές τα αποτελέσματα που παίρνουμε από το **Yacas** είναι μεγάλα και δύσκολα στο διάβασμα. Γι\' αυτό μας δίνεται η δυνατότητα να εκτυπώνονται τα
αποτελέσματα έτσι ώστε να τα καταλαβαίνουμε εύκολα με την βοήθεια της συνάρτησης `PrettyForm` (σε **ASCII text**).
Πχ. αν είχαμε ως αποτέλεσμα από έναν υπολογισμό την παράσταση:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
((3*x^2+1)/2!)+7*x+1/2*x^2-2*x+3/8
----------------------------------------------------------------------------------------------------------------------------------------------------------------
δίνοντας:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
In> PrettyForm(%); /* Το % παίρνει την προηγούμενη τιμή της εξόδου */
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Θα πέρναμε ως έξοδο:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
     2
3 * x + 1           1    2           3
--------- + 7 * x + - * x - 2 * x + -
    2               2                8
Out>True;
----------------------------------------------------------------------------------------------------------------------------------------------------------------
### [4. ΕΠΙΠΛΕΟΝ ΣΤΟΙΧΕΙΑ]{#s4}
Οι δυνατότητες του **Yacas** δεν σταματούν βέβαια εδώ. Το **Yacas** μπορεί να συνεργαστεί με άλλα προγράμματα όπως το **Gnuplot** και να μας δίνει πχ. το
αποτέλεσμα από έναν υπολογισμό πάνω στο καρτεσιανό επίπεδο σε ένα παράθυρο στα **X-Windows**.
Μπορεί να προσπελάσει αρχεία που έχουμε δημιουργήσει (κάποιον αλγόριθμο) και να τα εκτελέσει.Μια πολύ μεγάλη δυνατότητα που μας δίνει αυτό το πρόγραμμα είναι
οτι μπορούμε να ορίσουμε τις δικές μας συναρτήσεις που χρησιμοποιούμε καθημερινά και να το φέρουμε στα μέτρα μας. Όλα αυτά ελπίζω να τα προσθέσω σε μια
καινούρια έκδοση αυτής της παρουσίασης.
### [5. Yacas vs Others]{#s5}
Πολλοί από σας θα αναρωτηθήκατε γιατί να μπω στον κόπο να μάθω άλλο ένα τέτοιο πρόγραμμα, την στιγμή που υπάρχουν διάφορα άλλα, με πλήρη κατάλογο συναρτήσεων,
καλύτερη οργάνωση, τεράστια και αναλυτικά εγχειρίδια χρήσης, που είναι και καθιερωμένα στο χώρο και τα χρησιμοποιεί και πολύς κόσμος (βλέπε **Mathematica** και
**Scilab**).
Η απάντηση είναι απλή : γιατί το Yacas μπορεί να το αποκτήσει οποιοσδήποτε αφού διανέμεται κάτω από **GNU General Public License** (δεν γνωρίζω αν το Scilab
είναι κάτω από GPL αλλά νομίζω πως είναι) με ολόκληρο τον κώδικα μπροστά του και από την αλλή γιατί το μέγεθος του είναι **ελάχιστο** σε σχέση με τα άλλα
παρόμοια προγράμματα και με τις δυνατότητες που έχει.
Οπότε το μόνο που έχετε να κάνετε τώρα είναι να το κατεβάσετε στον υπολογιστή σας και να το δοκιμάσετε, γιατί όπως λέει ο λαός: \"καλό ακούγεται αλλά αν δεν το

217
content/articles/30/04_procmail.md Κανονικό αρχείο
Προβολή αρχείου

@ -0,0 +1,217 @@
+++
title = 'procmail'
date = '2001-09-01T00:00:00Z'
description = ''
author = 'Νίκος Αποστολάκης(mailto:nickapos@agriroot.aua.gr)'
issue = ['Magaz 30']
issue_weight = 4
+++
----------------------------------------------------------------------------------------------------------------------------------------------------------------
*USING **procmail**. Πώς;*
----------------------------------------------------------------------------------------------------------------------------------------------------------------
**1. Γενικά**
----------------------------------------
- [1.1 DISCLAIMER](#ss1.1)
- [1.2 Τι είναι το **procmail**](#ss1.2)
**2. Στο ψητό**
------------------------------------------
- [2.1 Η κατάσταση των διανομών σε σχέση με το **procmail** σήμερα](#ss2.1)
- [2.2 Εάν το **procmail** δεν έχει έρθει μαζί με την διανομή μου τι κάνω;](#ss2.2)
- [2.3 Κατάφερα να ξεκινήσω το **procmail** μετά τι κάνω;](#ss2.3)
**3. Παράδειγμα αρχείου procmailrc.**
----------------------------------------------------------------
**4. Bibliography**
----------------------------------------------
### [1. Γενικά]{#s1}
### [1.1 DISCLAIMER]{#ss1.1}
Δεν φέρω καμία ευθύνη εάν η εφαρμογή των παρακάτω προκαλέσει οποιουδήποτε είδους ζημία στο μηχάνημα σας ή στα δεδομένα σας.
### [1.2 Τι είναι το **procmail**]{#ss1.2}
Το **procmail** είναι ένα πρόγραμμα με το οποίο μπορείς να επεξεργαστείς, φιλτράρεις, ταξινομήσεις το e-mail σου. Με το **procmail** μπορείς επίσης να φτιάξεις
**auto-mail-responders, mailing lists** και πολλά άλλα.
### [2. Στο ψητό]{#s2}
### [2.1 Η κατάσταση των διανομών σε σχέση με το **procmail** σήμερα]{#ss2.1}
Το **procmail** έρχεται σήμερα ως ο **default mail delivery** agent σε SuSE 6.4 και Slackware 7.1.
Αυτό σημαίνει ότι όχι μόνο το **procmail** έρχεται έτοιμο σε αυτές τις διανομές αλλά και ότι το sendmail είναι έτσι ρυθμισμένο ώστε να χρησιμοποιεί το
**procmail** σαν mail delivery agent (MDA) αντί του παραδοσιακού mail. Σύμφωνα με τα παραπάνω συμπεραίνω (μπορεί και εσφαλμένα βέβαια) ότι το **procmail**
έρχεται ως ο default MDA στις περισσότερες διανομές.
### [2.2 Εάν το **procmail** δεν έχει έρθει μαζί με την διανομή μου τι κάνω;]{#ss2.2}
Εάν είναι αυτή η περίπτωση σας τότε θα πρέπει να κατεβάσετε το **procmail** απο το <http://www.procmail.org>, να το κάνετε compile σύμφωνα με τις οδηγίες που
σας δίνει και να το εγκαταστήσετε. Τώρα έχετε δύο επιλογές:
Mπορείτε να ρυθμίσετε το sendmail ώστε να χρησιμοποιεί απευθείας το **procmail** σαν MDA ή
Nα βάλετε μέσα στο .forward την παρακάτω γραμμή:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|exec /usr/bin/<bf/procmail/
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Βεβαίως υπάρχουν και άλλοι τρόποι για να ξεκινήσεις το **procmail** αλλά αυτοί ξεφεύγουν απο τον σκοπό αυτού του κειμένου ο οποίος είναι να δείξει τις βασικές
ρυθμίσεις και λειτουργίες του **procmail**.
### [2.3 Κατάφερα να ξεκινήσω το **procmail** μετά τι κάνω;]{#ss2.3}
Το **procmail** αφού ξεκινήσει διαβάζει τις οδηγίες που του έχετε γράψει εσείς μέσα στο **.procmailrc** στο home directory σας.\
Μέσα σε αυτο το αρχείο δηλώνονται κάποιες μεταβλητές περιβάλλοντος και οι οδηγίες επεξεργασίας του εισερχόμενου e-mail ας κοιτάξουμε ένα απο τα παραδείγματα που
δίνει το **procmail** μαζί με τον κώδικά του. Εξετάζουμε το **1procmailrc**
#### Οι μεταβλητές περιβάλλοντος
Στην αρχή δηλώνει κάποιες μεταβλητές περιβάλλοντος όπως το `PATH`, το `DEFAULT MAILBOX`, το `MAILDIRECTORY`, το `LOGFILE` και ένα `LOCKFILE`.
Το `MAILDIRECTORY` είναι το directory μέσα στο οποίο θα μπούν όλα τα αρχεία που θα δημιουργηθούν απο το **procmail** μετά απο την επεξεργασία των e-mail.
Το `DEFAULT MAILBOX` είναι το directory μέσα στο οποίο θα καταλήξουν τα e-mail που δεν θα πληρούν καμία απο τις συνθήκες φιλτραρίσματος απο αυτές που έχετε
γράψει παρακάτω. Δεν είναι απαραίτητο να ορίσετε `DEFAULT MAILBOX`. Εάν δεν ορίσετε `DEFAULT MAILBOX` τα e-mail θα παραμείνουν στο `/var/spool/username`.
Το `LOGFILE` είναι το αρχείο που καταγράφονται όλες οι κινήσεις του **procmail**.
Όσο για το `LOCKFILE` είναι το αρχείο που χρησιμοποιείται για το κλείδωμα του `DEFAULT MAILBOX` για να αποφευχθεί η περίπτώση να
έρθουν δύο e-mail συγχρόνως και να προσπαθόυν δύο **procmail** να γράψουν στο `DEFAULT MAILBOX` την ίδια στιγμή με αποτέλεσμα να
χάσετε ένα απο τα δύο e-mail.
#### Filtering rules
Ο τρόπος που συντάσσονται οι κανόνες φιλτραρίσματος για το **procmail** είναι ο παρακάτω:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
:0<flags>:lockfile
contitions
exactly one action.
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Φυσικά μπορούμε να χρησιμοποιήσουμε πολλα τέτοια block εντολών μέσα σε ένα .**procmailrc**
#### Flags
Στην πρώτη γραμμή δηλώνουμε ότι ξεκινάμε ένα νέο `block απο filtering rules` (χρησιμοποιώντας το `:0`). Δηλώνουμε με τι `flags` θέλουμε να γίνει αυτο το
φιλτράρισμα και αν θέλουμε όσο γίνεται αυτο να έχουμε κλειδωμένο το αρχείο ή τα αρχεία στα οποία αναφέρεται αυτο το `block` με ένα `lockfile`.
Μερικά απο τα πιο κοινά `flags` είναι το `c` και το `f` με το πρώτο δημιουργούμε ένα πιστό αντίγραφο του μυνήματος που βρίσκεται υπο επεξεργασία και δουλεύουμε
πάνω σε αυτό.\
Αυτό το flag χρησιμοποιείται όταν θέλουμε να στείλουμε ή να προωθήσουμε ένα μύνημα σε πολλούς παραλήπτες ή σε πολλούς φακέλους.
Το δεύτερο flag χρησιμοποιείται όταν θέλουμε να θεωρήσουμε το ένα `pipe` σαν φίλτρο. Φυσικά το πιο κοινό είναι να μην χρησιμοποιήσουμε καθόλου `flags` και να
επεξεργαστούμε το ίδιο το e-mail με το **procmail** χωρίς να το περάσουμε σε ένα άλλο πρόγραμμα ή να εργαστούμε πάνω σε ένα αντίγραφο του.
Υπάρχουν και άλλα πολλά `flags` τα οποία συνδιαζόμενα δίνουν στο **procmail** τεράστια ευελιξία αλλά δεν θα αναφερθούν έδω.\
Περιγράφονται αναλυτικά στο σχετικό manual page (**`man procmailrc`**).
#### Lockfiles
Το γιατί μπορεί κάποιος να θέλει να χρησιμοποιήσει `lockfiles` έχει αναφερθεί παραπάνω. Το όνομα ενός `lockfile` δηλώνεται ως εξής :
----------------------------------------------------------------------------------------------------------------------------------------------------------------
:0<flags>:lockfilename
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Μπορούμε να παραλείψουμε το όνομα του `lockfile` και η προηγούμενη έκφραση να γίνει η εξής
----------------------------------------------------------------------------------------------------------------------------------------------------------------
:0<flags>:
----------------------------------------------------------------------------------------------------------------------------------------------------------------
οπότε το **procmail** χρησιμοποιεί το όνομα του αρχείου στο οποίο αναφέρεται αυτο το `block` εντολών για να φτιάξει ένα `lockfile`.\
Ασφαλώς μπορούμε να μην χρησιμοποιήσουμε καθόλου `lockfile` σε ένα block εντολών οπότε η έκφραση γίνεται
----------------------------------------------------------------------------------------------------------------------------------------------------------------
:0<flags>
----------------------------------------------------------------------------------------------------------------------------------------------------------------
Υπάρχουν δύο περιπτώσεις όπου η χρήση `lockfile` δεν έχει νόημα. Η μια περίπτωση είναι αυτή οταν κατευθύνεις κάποιο μύνημα στο **/dev/null** και ή δέυτερη είναι
όταν κάνεις **forward** ένα μύνημα σε κάποια άλλη διέυθυνση e-mail (όπως στο παράδειγμα **procmailrc** ).
#### Conditions
Το **procmail** για να δει εάν το μύνημα που επεξεργάζεται αυτή την στιγμή πληρεί τις συνθήκες που εσείς του έχετε δηλώσει περνάει όλο το μύνημα μέσα απο την
**`egrep`** δίνοντας της σαν **`regular expression`** τα contitions που έχετε γράψει εσείς.
Δηλαδή τα contitions αυτά δεν είναι τίποτα άλλο απο **`regular expressions`**. Για περισσότερα για τις
**`regular expressions, man egrep.`**
#### Action(s)
Τα actions του **procmail** μπορεί να είναι οτιδήποτε (σχεδόν) απο ένα απλό όνομα οπότε το **procmail** γράφει τα μυνήματα που πληρούν τις συνθήκες σε ένα
αρχείο με αυτο το όνομα μέσα στο `MAILDIRECTORY`, μια ή πολλές e-mail adress οπότε το **procmail** απλά κάνει forward το μύνημα σε αυτές τις διευθύνσεις ή τέλος
το input οποιουδήποτε προγράμματος.\
Όπως έχω γράψει παραπάνω την σύνταξη των `filtering rules` είμαστε αναγκασμένοι να χρησιμοποιήσουμε μόνο ένα `action`. Μπορούμε
όμως με την χρήση των αγκύλων {} να κάνουμε `nest` πολλά `blocks` απο `actions` τα οποία μπορεί να είναι ακόμα και condition rules :
----------------------------------------------------------------------------------------------------------------------------------------------------------------
:0:
condition
{action1,action2,action3}
----------------------------------------------------------------------------------------------------------------------------------------------------------------
### [3. Παράδειγμα αρχείου procmailrc.]{#s3}
----------------------------------------------------------------------------------------------------------------------------------------------------------------
# Please check if all the paths in PATH are reachable, remove the ones that
# are not.
PATH=$HOME/bin:/usr/bin:/usr/ucb:/bin:/usr/local/bin:.
MAILDIR=$HOME/Mail # You'd better make sure it exists
DEFAULT=$MAILDIR/mbox
LOGFILE=$MAILDIR/from
LOCKFILE=$HOME/.lockmail
:0 # Anything from thf
* ^From.*thf@somewhere.someplace
todd # will go to $MAILDIR/todd
:0 # Anything from people at uunet
* ^From.*@uunet
uunetbox # will go to $MAILDIR/uunetbox
:0 # Anything from Henry
* ^From.*henry
henries # will go to $MAILDIR/henries
# Anything that has not been delivered by now will go to $DEFAULT
# using LOCKFILE=$DEFAULT$LOCKEXT
----------------------------------------------------------------------------------------------------------------------------------------------------------------
### [4. Bibliography]{#s4}
Καταλήγοντας θα ήθελα να πω ότι σε αυτό το άρθρο επιχείρησα να καλύψω τις απολύτως βασικές λειτουργίες του **procmail**, προσπαθώντας να είμαι σύντομος και
περιεκτικός. Για περισσότερες πληροφορίες παρακαλώ να αναφερθείτε στο documentation που έρχεται μαζί με τον κώδικα του **procmail** καθώς και στην σελίδα του

175
content/articles/30/05_lids.md Κανονικό αρχείο
Προβολή αρχείου

@ -0,0 +1,175 @@
+++
title = 'Linux Intrusion Detection System - μία παρουσίαση'
date = '2000-03-01T00:00:00Z'
description = ''
author = 'Μιχάλης Καμπριάνης'
issue = ['Magaz 30']
issue_weight = 5
+++
----------------------------------------------------------------------------------------------------------------------------------------------------------------
*Το LIDS, Linux Intrusion Detection System είναι ένα add-on του πυρήνα του linux, που συνοδεύεται από ένα admin tool, το οποίο φροντίζει να κάνει το σύστημά μας
κάπως πιο\... \"ασφαλές\"*
----------------------------------------------------------------------------------------------------------------------------------------------------------------
**1. Εισαγωγή**
--------------------------------------
**2. Capabilities**
------------------------------------------
- [2.1 Τι είναι τα capabilities?](#ss2.1)
- [2.2 Δεν κατάλαβα τι μου παρέχουν\...](#ss2.2)
- [2.3 Δεν μου αναφέρεις μερικά capabilities;](#ss2.3)
**3. LIDS λοιπόν\...**
---------------------------------------------
- [3.1 Το kernel-patch](#ss3.1)
- [3.2 Το lidsadm](#ss3.2)
**4. Άρα\....**
--------------------------------------
- [4.1 Hints and tricks](#ss4.1)
- [4.2 Που το βρίσκω; Άλλο Documentation;](#ss4.2)
- [4.3 Disclaimer και συμπεράσματα.](#ss4.3)
### [1. Εισαγωγή]{#s1}
Το linux, ως unix-type λειτουργικό, κουβαλάει μαζί του κάποιες αδυναμίες των παλιών και άλλων unices. Μία από αυτές τις αδυναμίες, έχει να κάνει με το
γενικότερα σύστημα authorization, όπου υπάρχουν πάρα πολλά πράγματα, που μπορεί να τα κάνει μόνο το παντοδύναμο root account\... Αυτό το σχήμα της ασφάλειας,
θεωρείται ξεπερασμένο, εφόσον
- υπάρχουν πάρα πολλά πράγματα που γίνονται μόνο από το root account, αναγκάζοντάς μας έτσι αφενός να κάνουμε πολλά προγράμματα setuid root, αφετέρου να
μοιράζουμε το root password σε πολλά άτομα αν μιλάμε για μία φάρμα servers με πολλούς operators.
- αρκεί για κάποιον εισβολέα να αποκτήσει το root password για να έχει πλήρη έλεγχο στο σύστημα.
- προγράμματα που είναι άσχετα με το λειτουργικό (π.χ. sendmail στις παλαιότερες εκδόσεις), ακριβώς επειδή πρέπει να τρέχουν με root privileges, αποτελούν
κίνδυνο γενικότερης ασφάλειας στο σύστημα, και όχι μόνο για την υπηρεσία που εξυπηρετούν αυτή καθ\' αυτή.
Πολλά από αυτά τα θέματα, θα μπορούσαν να ξεπεραστούν με χρήση των capabilities, ένα \"τρικ\", το οποίο προστέθηκε στην έκδοση 2.2 του Linux kernel.
### [2. Capabilities]{#s2}
### [2.1 Τι είναι τα capabilities?]{#ss2.1}
Τα capabilities είναι ένα set, όπως λέει και το όνομά τους, δυνατοτήτων, που ορίζονται μέσα στον πυρήνα, και περιορίζουν τις δυνατότητες του root που μέχρι τώρα
ξέραμε ότι είχε (και των setuid root προγραμμάτων αντίστοιχα). Τα capabilites ορίστηκαν από κάποιο POSIX draft (το οποίο τώρα αποσύρθηκε), ενώ ο πυρήνας του
Linux έχει και πολλά capabilities τα οποία δεν αναφέρονται στο draft αλλά είναι linux-specific.\
Ένα παράδειγμα capability, είναι το CAP\_CHOWN το οποίο επιτρέπει την αλλαγή ιδιοκτήτη ενός αρχείου. Όπως καταλαβαίνετε, για να κάνουμε chown ένα αρχείο, πρέπει
να είμαστε ο root, άρα ένα πρόγραμμα που θέλουμε να κάνει chown πρέπει να είναι setuid root. Κάτι τέτοιο όμως αυτόματα σημαίνει ότι το ίδιο πρόγραμμα, θα μπορεί
να διαβάσει το αρχείο /etc/shadow, δημιουργώντας έτσι, για κάτι τόσο απλό, μία τρύπα ασφαλείας στο σύστημα. Με χρήση των capabilities, μπορεί το setuid root
πρόγραμμα να αρχίσει να τρέχει, και μετά να \"ρίξει\" όλα τα capabilities που δεν χρειάζεται και να κρατήσει μόνο το cap\_chown. Μπορεί επίσης, να αλλάξει το
effective uid και πλέον να μην μπορεί καν να ανακτήσει τα dropped capabilities.
### [2.2 Δεν κατάλαβα τι μου παρέχουν\...]{#ss2.2}
Λογικό, γιατί ακόμα, δεν μας παρέχουν τίποτα. Για να τα λέμε σωστά τα πράγματα, πρέπει η εφαρμογή μας να γραφτεί έτσι ώστε να χρησιμοποιεί τα capabilities,
αλλιώς δεν κερδίζουμε τίποτα.. Γι αυτό ξεκίνησε και το project LIDS (Linux Intrusion Detection System) το οποίο παρέχει απλά ένα layer μεταξύ του συστήματος
(kernel) και των εφαρμογών, για να επιβάλλει την χρήση capabilities σε ήδη γραμμένες εφαρμογές.
### [2.3 Δεν μου αναφέρεις μερικά capabilities;]{#ss2.3}
Αμέ\... Το CAP\_CHOWN που είδαμε πιο πάνω, το CAP\_NET\_BIND\_SERVICE που επιτρέπει σε μία εφαρμογή να ανοίξει ένα port κάτω από το 1024 (privileged ports), το
CAP\_SYS\_PTRACE που επιτρέπει την χρήση της ptrace() σε οποιοδήποτε process\...\
Μία πλήρη λίστα για τον δικό σας πυρήνα, θα βρείτε εδώ:
/usr/src/linux/include/linux/capability.h
### [3. LIDS λοιπόν\...]{#s3}
Το LIDS αποτελείται από δύο κομμάτια: ένα (μεγαλούτσικο) kernel patch, και ένα administration πρόγραμμα, το lidsadm. Ας τα δούμε ξεχωριστά.
### [3.1 Το kernel-patch]{#ss3.1}
Παρέχει τις εξής extra παραμέτρους στον πυρήνα:
- CONFIG\_LIDS: όπως λέει και το όνομά του, ενεργοποίηση του LIDS.
- CONFIG\_LIDS\_HANGUP: κάθε φορά που κάποιο πρόγραμμα προσπαθεί να κάνει κάτι που απαγορεύεται από το LIDS, τότε η κονσόλα στην οποία το πρόγραμμα είναι
attached θα κλείνει.
- CONFIG\_LIDS\_SA\_EXEC\_UP: κάθε φορά που εκτελείται ένα πρόγραμμα μη προστατευμένο πριν μπει σε \"λειτουργία\" το LIDS (κατά τη διάρκεια του boot προφανώς)
θα δημιουργείται ένα security alert.
- CONFIG\_LIDS\_NO\_EXEC\_UP: με αυτή την επιλογή το LIDS θα αρνηθεί να τρέξει μη προστατευμένα προγράμματα πριν αυτό μπει σε \"λειτουργία\".
- CONFIG\_LIDS\_INIT\_CHILDREN\_LOCK: με αυτή την επιλογή θα προστεθεί η δυνατότητα να αποκλειστούν κάποια στιγμή (την οποία επιλέγουμε εμείς) όλοι οι τρόποι
για να σκοτώσει κάποιος ένα process του οποίου το parent process είναι η init.
- CONFIG\_LIDS\_NO\_FLOOD\_LOG: Αν ένα μήνυμα του LIDS επαναλαμβάνεται επί μακρόν, το LIDS θα σταματήσει να το γράφει στα logs για να μην τα γεμίσει.
- CONFIG\_LIDS\_PORT\_SCAN\_DETECTOR: Με αυτή την επιλογή θα δημιουργηθεί μέσα στον kernel ένας port scanner detector, και για κάθε port scan το LIDS θα
καταγράφει τα απαιτούμενα μηνύματα στα logs.
- CONFIG\_LIDS\_TIMEOUT\_AFTER\_FLOOD: Είναι ο χρόνος τον οποίο πρέπει να απέχουν μεταξύ τους δύο διαφορετικά security alerts για να καταγραφούν.
- CONFIG\_LIDS\_ALLOW\_SWITCH: Με αυτή την επιλογή μπορεί να \"απενεργοποιηθεί\" προσωρινά το LIDS.
- CONFIG\_LIDS\_MAX\_TRY: Πόσες φορές θα δεχθεί λάθος password το LIDS πριν \"κλειδώσει\" για λίγο τη δυνατότητα απενεργοποίησής του.
- CONFIG\_LIDS\_TTW\_FAIL: Πόση ώρα θα κρατάει το \"κλείδωμα\" που λέγαμε πιο πάνω.
- CONFIG\_LIDS\_REMOTE\_SWITCH: Με αυτή η επιλογή, η απενεργοποίηση θα είναι δυνατή και από απόμακρο τερματικό, αλλιώς, μόνο από την κονσόλα.
- CONFIG\_LIDS\_ALLOW\_ANY\_PROG\_SWITCH: Κανονικά μόνο το /sbin/lidsadm μπορεί να απενεργοποιήσει το LIDS αλλά με αυτή την επιλογή, μπορούμε να επιτρέψουμε
και σε άλλα προγράμματα να κάνουν κάτι τέτοιο.
- CONFIG\_LIDS\_RELOAD\_CONF: Επιτρέπει την επανανάγνωση του αρχείου ρυθμίσεων του LIDS χωρίς να χρειάζεται reboot.
- CONFIG\_LIDS\_SA\_THROUGH\_NET: Με αυτή την επιλογή, τα security alerts στέλνονται δια μέσω του δικτύου, και γι αυτό πρέπει να οριστούν ορισμένες ρυθμίσεις,
τις οποίες θα δούμε παρακάτω.
- CONFIG\_LIDS\_HIDE\_KLIDS: Με αυτή την επιλογή, το process του Lids θα κρύβεται από το /proc (άρα δεν θα φαίνεται στα ps, top κλπ).
- CONFIG\_LIDS\_NET\_MAX\_TRIES: Πόσες φορές θα προσπαθήσει το LIDS να στείλει το security alert μέσω δικτύου.
- CONFIG\_LIDS\_NET\_TIMEOUT: Πόση ώρα θα είναι το timeoute μεταξύ των προσπαθειών να σταλεί το μήνυμα μέσω δικτύου.
- CONFIG\_LIDS\_MSGQUEUE\_SIZE: Πόσο μεγάλη να είναι η ουρά των μηνυμάτων που θα σταλούν μέσω δικτύου. Μόλις γεμίσει η ουρά, δεν θα καταγράφονται άλλα
μηνύματα (μέχρι να ξανααδειάσει προφανώς).
### [3.2 Το lidsadm]{#ss3.2}
Το πρόγραμμα /sbin/lidsadm είναι απαραίτητο για να μπορούμε να χρησιμοποιήσουμε σωστά και αποδοτικά το LIDS. Δεν θα μπούμε βέβαια σε λεπτομέρειες χρήσης, θα
πούμε μόνο ότι με αυτό το πρόγραμμα:
- μπορούμε να θέσουμε κάποια αρχεία και directories σε read-only για όλες τις processes του συστήματος, ακόμα και τις root-owned processes. Παράδειγμα το
/usr/lib
- μπορούμε να θέσουμε κάποια αρχεία σε append-only mode (θυμηθείτε Windows-NT και permission to write), όπως για παράδειγμα το /var/log/messages
- μπορούμε να θέσουμε κάποια αρχεία σε hidden για όλες τις processes, όπως το /etc/shadow\...
- \...δίνοντας σε συγκεκριμένα προγράμματα το δικαίωμα να τα διαβάζουν, όπως το /bin/login
- μπορούμε να ορίσουμε τα capabilities που θα αφαιρέσουμε από **όλα** τα προγράμματα, όταν θα κλειδώσουμε τον πυρήνα, π.χ. το CAP\_SYS\_MODULE
- μπορούμε να προσθέσουμε κάποια από αυτά που αφαιρέσαμε globally, σε συγκεκριμένα executables
- με τη δυνατότητα να γίνονται inherited στα child processes
- μπορούμε να απενεργοποιήσουμε προσωρινά το LIDS (για να θέσουμε νέες ρυθμίσεις π.χ.)\...
- \... και να το επανενεργοποιήσουμε αφού του ζητήσουμε να διαβάσει το configuration ξανά
- μπορούμε να \"κρύψουμε\" processes
- ή μπορούμε να τα κάνουμε να αγνοούν το kill
Νομίζω ότι πιάσατε την κεντρική ιδέα. Υπάρχουν βέβαια περιορισμοί. Συγκεκριμένα, τα file-attributes που θέτουμε, τίθενται με βάση το inode, άρα δεν μπορούμε να
κλειδώσουμε το /etc directory και να περιμένουμε να δουλεύει η εντολή passwd (η οποία αναδημιουργεί το password file κάθε φορά, άρα αυτό αποκτά άλλο inode κάθε
φορά, συνεπώς ΔΕΝ μπορούμε να δώσουμε full privilege στην εντολή passwd πάνω σε αυτό το αρχείο).
### [4. Άρα\....]{#s4}
### [4.1 Hints and tricks]{#ss4.1}
Πολύ χρήσιμο κρίνεται το remote logging που παρέχει το LIDS. Πρέπει να δοθεί προσοχή στις ρυθμίσεις (σε ποιο server θα κάνει logging, με ποια μέθοδο κλπ) και να
σχεδιαστεί σωστά το δίκτυο ούτως ώστε να μην έχουμε \"κομμένες\" γραμμές εκεί (π.χ. κάποιος αποφάσισε να βάλει ένα firewall ανάμεσα στα συστήματά μας :-).\
Θέλει σοβαρή μελέτη το ποια αρχεία/directories θα κλειδώσουμε, πόσο θα τα κλειδώσουμε (όπως είπαμε μπορούμε να τα κρύψουμε εντελώς, να τα κάνουμε μόνο
ανάγνωσης, να τα κάνουμε μόνο append ή να τα κάνουμε εγγραφής/ανάγνωσης), σε ποια προγράμματα θα δώσουμε δικαίωμα να προσπελαύνουν τα αρχεία/directories
αυτά\... Το μόνο σίγουρο είναι ότι δεν υπάρχει συνταγή, και μάλλον είναι δύσκολο να γραφτεί μία. Μην εμπιστευτείτε καμία συνταγή, αν πρόκειται για production
σύστημα.\
Πρέπει επίσης να μελετηθεί σωστά το σε ποια αρχεία/executables θα δοθούν τα capabilities που θα επιτρέπουν να κάνουν unmount τα filesystems και να τερματίζουν
διεργασίες, για να μπορεί το σύστημα να \"κατεβαίνει\" κανονικά, και να μην κάνει fsck σε κάθε boot, ούτε να βρίσκει \"ανοιχτά\" processes.\
Σε κάθε περίπτωση, **πρέπει** να επιτραπεί το switching κατά το compile του πυρήνα, για να μπορείτε να απενεργοποιήσετε το lids προσωρινά. Αλλιώς, το root
account, σε μία normal εγκατάσταση, θα είναι τόσο περιορισμένο που θα είναι άχρηστο.\
Τέλος, αν δείτε ότι το σύστημα δεν καλο-δουλεύει μετά τις αλλαγές που κάνατε, ένα security=0 σαν command parameter στο lilo θα σας δώσει τη δυνατότητα να
ξεκινήσετε το σύστημα με το LIDS απενεργοποιημένο.
### [4.2 Που το βρίσκω; Άλλο Documentation;]{#ss4.2}
Που το βρίσκετε; Μα που αλλού, εκτός από το <http://www.lids.org>. Εκεί θα βρείτε, εκτός από τα patches για τους πυρήνες της σειράς 2.4 και της σειράς 2.2, και
διάφορα links για documentation. Το δικό τους FAQ, links για άρθρα που έχουν γραφτεί για το LIDS, links για reviews, link για εκείνο το POSIX draft\....\
Καλό θα ήταν βέβαια να υπήρχε ένα graphical configuration utility (πεδίον δόξης λαμπρό για τους απανταχού qt ή gtk programmers) αλλά δεν έχει γραφτεί κάποιο
τέτοιο ακόμα από ότι ξέρω. Ιδού η Ρόδος\....
### [4.3 Disclaimer και συμπεράσματα.]{#ss4.3}
Δεν χρειάζεται βέβαια να πω ότι η χρήση του LIDS δεν προτείνεται αν είστε αρχάριος. Σε κάθε περίπτωση, για ότι κάνετε με το LIDS (ή και χωρίς αυτό :-) δεν φέρω
καμία ευθύνη. Διαβάστε το documentation, ξαναδιαβάστε το, κι αν είστε έτοιμοι, πάρτε ένα backup τα αρχεία σας και δοκιμάστε το\...
Το LIDS δεν μου φάνηκε ακόμα έτοιμο για production servers, κυρίως λόγω της έλλειψης documentation και ενός εύκολου configuration utility. Όπως ξαναείπα, ιδού
πεδίο δόξης λαμπρό\...\
Η αλήθεια είναι πάντως, ότι παρέχει ένα επίπεδο ακόμα ασφαλείας στο παλιό γνωστό και ταλαιπωρημένο Unix-security scheme\... Μόλις δοθεί η δυνατότητα υποστήριξης
capabilities και στο filesystem, όλα θα είναι καλύτερα :-)