Witamy, Gość. Zaloguj się lub zarejestruj.

Autor Wątek: Cout podwójnie wyświetla  (Przeczytany 1632 razy)

0 Użytkowników i 1 Gość przegląda ten wątek.

Abik

Cout podwójnie wyświetla
« dnia: Grudzień 14, 2011, 20:38:43 »
Chodzi o coś takiego:

po zalogowaniu usera podwójnie wyświetla tą całą sekwencję zachęty : (

sam nie wiem szczerze mówiąc co może nie grać bo wydaje mi się wszystko ok, ale może nie wiem o jakimś detalu związanym ze strumieniami (tych detali jest od zasrania) i stąd ten mini error
jak się nie uda naprawić to kij, ale brzydko mi to wygląda -- . -- w każdym razie ja będę kombinować z tym bo mi się nie podoba ;s


aha! jak dotąd próbowałem dać cout.flush() gdzie się tylko dało i wycinałem ostatni znak z tego co pobierał cin przy logowaniu, żeby na wszelki wypadek nie okazało się, że pobiera jakieś śmieci, ale tak jak myślałem, nic takiego nie miało miejsca, także te dwa pomysły odpadają ;s


tu cały kod programu(chociaż to raczej rodzaj problemu, który albo się zna, albo się nie zna : d ) (na razie tylko 200 linii więc da się raz dwa przelecieć : p ):
#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <conio.h>
#include <string>
using namespace std;

//DO ZROBIENIA
//dokonczyc dodawanie plikow
//usuwanie plikow
//zmiana trybu
//zmiana wlasciciela
//zmiana grupy

////===============================================================struktury danych
struct inode{
int u;
int g;
int o;
int UID;
int GID;
};

struct usermask{
int u;
int g;
int o;
};

struct lista_plikow{
string nazwa;
int numer_indoa;
lista_plikow * next_el;
};

struct user{
string nazwa;
int GID; //do jakiej grupy nalezy
bool zalogowany;
};

struct group{
string nazwa;
int zalogowani[3]; //zawiera UID uztykownikow ktorzy naleza do grupy
};

//=================================================================zmienne globalne
string login;
bool logowanie;
bool wyjscie = false;

lista_plikow * poczatek = NULL;
inode * tablica_inodow;
usermask umask;
int rozmiar;

//grupy i uzytkownicy
user tablica_userow[3];
user user1;
user user2;
user user3;
group tablica_grup[2];
group grupa12;
group grupa3;

//================================================================push
void push(){

}

//===============================================================nowy_plik
void nowy_plik(string plik){  //ma pobierac nazwe pliku i tworzyc nowy element na liscie i odpowiadajacego jej inoda
inode inodeTmp;
inodeTmp.u = 6 - umask.u;
if(inodeTmp.u < 0) inodeTmp.u = 0;
inodeTmp.g = 6 - umask.g;
if(inodeTmp.g < 0) inodeTmp.g = 0;
inodeTmp.o = 6 - umask.o;
if(inodeTmp.o < 0) inodeTmp.o = 0;
tablica_inodow[0] = inodeTmp;//dodaje inoda do tablicy //tu trzeba zmienic ten indeks tablicy!!!!!!
}

//===============================================================usun_plik
void usun_plik(){

}

//===============================================================wyswietl_pliki
void wyswietl_pliki(){

}

//===============================================================zaloguj
bool zaloguj(){
cout << "login: ";
cin >> login;

//switch(user)
if(login == "user1")
tablica_userow[0].zalogowany = true;
else if(login == "user2")
tablica_userow[1].zalogowany = true;
else if(login == "user3")
tablica_userow[2].zalogowany = true;
else{
cout << "LOGIN ERROR" << endl;
return false;
}
return true;
}

//===============================================================pobierz_komende
void pobierz_komende(){ //pobrac chara i zamienic na stringa!
cout << login << ": ~# ";
string komenda;
getline(cin, komenda);

if(komenda == "logout"){
logowanie = false;
for(int i = 0; i<3 ; i++)
tablica_userow[i].zalogowany = false;
}
else if(komenda == "exit"){ //podobne do powyzszego ifa ale dodadkowo wyjscie = true
logowanie = false;
wyjscie = true;
for(int i = 0; i<3 ; i++)
tablica_userow[i].zalogowany = false;
}
else if(komenda.substr(0, 5) == "touch"){
string plik = komenda.substr(6, (komenda.size()-5));
nowy_plik(plik);
}
else if(komenda.substr(0, 5) == "umask"){
if(komenda.size() == 5)
cout << umask.u << umask.g << umask.o << endl;
else {
string uTmp = komenda.substr(6, 1); //(komenda.size()-5));
int uTmp2 = atoi(uTmp.c_str());
umask.u = uTmp2;
string gTmp = komenda.substr(7, 1);
int gTmp2 = atoi(gTmp.c_str());
umask.g = gTmp2;
string oTmp = komenda.substr(8, 1);
int oTmp2 = atoi(oTmp.c_str());
umask.o = oTmp2;
}
}
}

//===============================================================init
int init(){
int rozmiarTmp=0;
FILE * plik;
plik = fopen("config.txt", "r");
fscanf(plik, "%d", &rozmiarTmp);
fclose(plik);
return rozmiarTmp;
}

int _tmain(int argc, _TCHAR* argv[])
{
rozmiar = init(); //cout << rozmiar << endl;

//===============================================================umask
umask.u = 0;
umask.g = 0;
umask.o = 2;

tablica_inodow = new inode [rozmiar];

//===============================================================uzytkownicy
user1.nazwa = "user1";
user1.GID = 0;
user1.zalogowany = false;
tablica_userow[0] = user1;

user2.nazwa = "user2";
user2.GID = 0;
user2.zalogowany = false;
tablica_userow[1] = user2;

user3.nazwa = "user3";
user3.GID = 1;
user3.zalogowany = false;
tablica_userow[2] = user3;

//===============================================================grupy
grupa12.nazwa = "grupa12";
grupa12.zalogowani[0] = 0;
grupa12.zalogowani[1] = 1;

grupa3.nazwa = "grupa3";
grupa3.zalogowani[0] = 2;

//===============================================================petla programu
while(!wyjscie){
logowanie = zaloguj();
while(logowanie){
pobierz_komende();
}
}

cout << "Wcisnij dowolny przycisk aby zakonczyc!" << endl;
_getch();
return 0;
}


« Ostatnia zmiana: Grudzień 14, 2011, 20:40:25 wysłana przez Abik »

Abik

Odp: Cout podwójnie wyświetla
« Odpowiedź #1 dnia: Grudzień 15, 2011, 13:36:51 »
Ok pany, naprawiłem sobie to, na przyszłość dla was, problem był taki.
Otóż "login" pobierałem tak:
cin >> login;i po "zalogowaniu" program wykonywał mi funkcję "pobierz_komende" z ENTEREM (czy może bardziej fachowo, znakiem nowej linii) jako parametrem o.O wychodzi z tego na to, że cin pobierał mi oczekiwany login razem z tym enterem... naprawienie tego był banalnie proste, wystarczyło wymienić powyższą linię kodu, na poniższą:
getline(cin, login);nie wpadł bym na to gdybym wcześniej nie miał problemów z funkcją "pobierz_komende" gdzie komendy pobierałem też cin'em z operatorem >> ... ale on pobierał wtedy je tylko do pierwszego białego znaku (spacja, enter...), a niektóre komendy mają dodatkowe parametry, więc musiałem poszukać czegoś innego i getline nadał się idealnie

to tak na przestrogę dla wszystkich, którzy korzystają z tego dziadowskiego operatora >> :D

przy okazji jak ktoś ma apetyt, to może sobie poczytać nowszą wersję:
#include "stdafx.h"
#include <iostream>
#include <stdio.h>
#include <conio.h>
#include <string>
using namespace std;

//DO ZROBIENIA
//zmiana trybu-chmod //zmiana grupy-chgrp
//zmiana wlasciciela-root only

////===============================================================struktury danych
struct inode{
int u;
int g;
int o;
int UID;
int GID;
bool usuniety;
};

struct usermask{
int u;
int g;
int o;
};

struct katalog{
string nazwa;
int numer_inoda;
katalog * next_el;
};

struct user{
string nazwa;
int GID; //do jakiej grupy nalezy
string grupa; //nazwa tej grupy
bool zalogowany;
};

struct group{
string nazwa;
};

//=================================================================zmienne globalne
string login;
bool logowanie;
bool wyjscie = false;
int zalogowany;

inode * tablica_inodow;
katalog * pierwszy;
usermask umask;

int rozmiar_inodow; //maksymalna liczba tworzona dynamicznie z pliku config.txt
int liczba_inodow; //liczba aktualnie istniejacych inodow stworzonych w funkcji nowy_plik
int liczba_plikow; //praktycznie liczba pozycji na liscie w katalogu

int rozmiar_userow; //analogiczna sytuacja
int liczba_userow; //jak dla inodow

//grupy i uzytkownicy
user * tablica_userow;
user root;

group tablica_grup[3];
group grupa1; //grupa dla roota
group grupa2; //grupa dla userow o UID nieparzystym
group grupa3; //grupa dla userow o UID parzystym

//================================================================istnieje
bool istnieje(string plik){
katalog * tmp = pierwszy;

while(tmp){
if(tmp->nazwa == plik)
return true;
tmp = tmp->next_el;
}
return false;
}

//================================================================push
void dodaj(string nazwa, int inode_number){
katalog *nowy = new katalog;
katalog *tmp1 = pierwszy;
katalog *tmp2 = NULL;

nowy->nazwa = nazwa;
nowy->numer_inoda = inode_number;

while(tmp1 != NULL){
tmp2 = tmp1; //tmp zawsze jest poprzednikiem tmp1
tmp1 = tmp1->next_el;
}
if(pierwszy == NULL){
nowy->next_el = pierwszy;
pierwszy = nowy;
} else {
tmp2->next_el = nowy;
nowy->next_el = tmp1;
}
}

//===============================================================czy_max_plikow
int czy_max_plikow_i_jakis_usuniety(){
int usuniety = 0;
if(liczba_plikow != liczba_inodow){
for(; usuniety < liczba_inodow; usuniety++){
if(tablica_inodow[usuniety].usuniety == true)
return usuniety;
}
} else {
if(liczba_inodow == rozmiar_inodow)
return -2;
else
return -1;
}
}


//===============================================================nowy_plik
void nowy_plik(string plik){  //ma pobierac nazwe pliku i tworzyc nowy element na liscie i odpowiadajacego jej inoda
if(istnieje(plik))
cout << "File '" << plik << "' already exist" << endl;
else{
inode inodeTmp;
inodeTmp.usuniety = false;

inodeTmp.u = 6 - umask.u;
if(inodeTmp.u < 0) inodeTmp.u = 0;
inodeTmp.g = 6 - umask.g;
if(inodeTmp.g < 0) inodeTmp.g = 0;
inodeTmp.o = 6 - umask.o;
if(inodeTmp.o < 0) inodeTmp.o = 0;

inodeTmp.UID = zalogowany; //przypisanie wlasciciela
inodeTmp.GID = tablica_userow[zalogowany].GID; //przypisanie grupy

int nr_wolnego_inoda = czy_max_plikow_i_jakis_usuniety();
if(nr_wolnego_inoda == -1){
tablica_inodow[liczba_inodow] = inodeTmp;//dodaje inoda do tablicy
dodaj(plik, liczba_inodow);//wpis do listy plikow - katalogu

liczba_plikow++;
liczba_inodow++; //zwiekszamy dopiero tutaj, zeby nr inoda zgadzal sie z tym zapisanym na liscie plikow
}
else if(nr_wolnego_inoda >= 0){
tablica_inodow[nr_wolnego_inoda] = inodeTmp;//dodaje inoda do tablicy
dodaj(plik, nr_wolnego_inoda);//wpis do listy plikow - katalogu

liczba_plikow++;
}
else if(nr_wolnego_inoda == -2)
cout << "Cannot create file: No free disc space available." << endl;
}
}


//===============================================================usun_plik
void usun_plik(string plik){
katalog * tmp = pierwszy;
katalog * tmp2;
int test = 0; //jesli wartosc tej zmiennej bedzie taka
  //jak liczba plikow w systemie, tzn. ze plik nie istnieje
while(tmp){
if(tmp->nazwa == plik){
tablica_inodow[tmp->numer_inoda].usuniety = true;
tmp2->next_el = tmp->next_el;
delete tmp;
liczba_plikow--;
break;
}
tmp2 = tmp; //tmp2 jest zawsze poprzednikiem tmp
tmp = tmp->next_el;
test++;
}
if(test == liczba_plikow)
cout << "rm: cannot remove '" << plik << "': No such file" << endl;
}

//===============================================================wyswietl_pliki
void wyswietl_pliki(int przelacznik, bool il){
katalog * tmp = pierwszy;

if(przelacznik == 1){ //ls
while(tmp){
cout << tmp->nazwa << " ";
tmp = tmp->next_el;
}
cout << endl;
}
if(przelacznik == 2){//ls -i
while(tmp){
cout << tmp->numer_inoda << " " << tmp->nazwa << " ";
tmp = tmp->next_el;
}
cout << endl;
}
if(przelacznik == 3){
while(tmp){
int tmpNum = tmp->numer_inoda;
int userID = tablica_inodow[tmpNum].UID;
int groupID = tablica_inodow[tmpNum].GID;

if(il)
cout << tmp->numer_inoda << " ";
cout << "-"; //typ pliku, tutaj zawsze zwykly plik
switch(tablica_inodow[tmpNum].u){ //uprawnienia wlasciciela
case 6: cout << "rw-"; break; //rw
case 5: cout << "r-x"; break; //rx
case 3: cout << "-wx"; break; //wx
case 4: cout << "--x"; break; //r
case 2: cout << "-w-"; break; //w
case 1: cout << "r--"; break; //x
case 7: cout << "rwx"; break; //rwx
}
switch(tablica_inodow[tmpNum].g){ //uprawnienia grupy
case 6: cout << "rw-"; break; //rw
case 5: cout << "r-x"; break; //rx
case 3: cout << "-wx"; break; //wx
case 4: cout << "--x"; break; //r
case 2: cout << "-w-"; break; //w
case 1: cout << "r--"; break; //x
case 7: cout << "rwx"; break; //rwx
}
switch(tablica_inodow[tmpNum].o){ //uprawnienia innych
case 6: cout << "rw-"; break; //rw
case 5: cout << "r-x"; break; //rx
case 3: cout << "-wx"; break; //wx
case 4: cout << "--x"; break; //r
case 2: cout << "-w-"; break; //w
case 1: cout << "r--"; break; //x
case 7: cout << "rwx"; break; //rwx
}
cout << " " << "1" << " " //dowiazania do pliku, tutaj zawsze 1
<< tablica_userow[userID].nazwa << " " //wyswietla wlasciciela
<< tablica_grup[groupID].nazwa << " " //wyswietla grupe
<< "0" << " " //wielkosc pliku w bajtach
<< tmp->nazwa << endl; //tutaj jeszcze wyswietlic nazwe pliku
tmp = tmp->next_el; //przesuwamy sie na nastepny plik
}
}
}

//===============================================================zaloguj
bool zaloguj(){
cout << "login: ";
getline(cin, login);

if(login != "---"){
int i = 0;
for(; i < liczba_userow; i++){
if(login == tablica_userow[i].nazwa){
tablica_userow[i].zalogowany = true;
zalogowany = i; //zapamietywanie jaki user jest zalogowany
break; //wyjscie z petli jesli udalo sie zalogowac
}
}
if(i == liczba_userow){
cout << "Login incorrect" << endl;
return false;
}
}
else {
cout << "Login incorrect" << endl;
return false;
}
return true;
}

//===============================================================dodaj_usera
void dodaj_usera(string username, bool zwieksz_liczbe_userow){ //UID nowego usera = akutalna wartosc
user userTmp; //zmiennej liczba userow!
userTmp.nazwa = username;
if((liczba_userow % 2) == 0){ //jesli ma parzyste UID to do grupy3
userTmp.GID = 2;
userTmp.grupa = "grupa3";
}
else { //jesli nieparzyste UID to do grupy2
userTmp.GID = 1;
userTmp.grupa = "grupa2";
}
userTmp.zalogowany = false;

if(zwieksz_liczbe_userow){ //liczba ta nie moze byc zwiekszana, jesli dodawani sa nowi
tablica_userow[liczba_userow] = userTmp; //uzytkownicy na pozycjach userow usunietych
liczba_userow++;  
}
else{
for(int i = 0; i < liczba_userow; i++){ //jesli tablica jest pelna, ale sa w niej usunieci userzy
if(tablica_userow[i].nazwa == "---"){//to wtedy w tej petl1i sa oni znajdowani i zastepowani
if((i%2) == 0){ //nowo tworzonym userem
userTmp.GID = 2;
userTmp.grupa = "grupa3";
}
tablica_userow[i] = userTmp;
break;
}
}
}
}

//===============================================================usun_usera
void usun_usera(string username){
for(int i = 0; i < liczba_userow; i++){
if(tablica_userow[i].nazwa == username){
tablica_userow[i].nazwa = "---";
tablica_userow[i].grupa = "---";
tablica_userow[i].GID = -1;
}
}
}

//===============================================================wyswietlanie_userow
void wyswietl_userow(){ //format: nazwa_usera:haslo-x:UID:GID:nazwa_grupy:katalog_domowy ~
for(int i = 0; i < liczba_userow; i++)
if(tablica_userow[i].nazwa != "---")//nie wyswietlac usunietych userow
cout << tablica_userow[i].nazwa << ":x:" << i << ":" << tablica_userow[i].GID << ":" << tablica_userow[i].grupa << ":" << "~" <<endl;
}

//===============================================================czy_max_userow
bool czy_max_userow_i_jakis_usuniety(){
int usuniety = 0; //to ostatecznie bedzie indeks pierwszego usunietego usera
for(; usuniety < liczba_userow; usuniety++){
if(tablica_userow[usuniety].nazwa == "---")
break;
}
if((liczba_userow == rozmiar_userow) && (usuniety < liczba_userow)) return true;
else return false;
}

//===============================================================pobierz_komende
void pobierz_komende(){
if(zalogowany == 0) //rozne znaki zachety dla roota i zwyklych userow
cout << login << ": ~# ";
else
cout << login << ": ~$ ";
string komenda;
getline(cin, komenda);

if(komenda.substr(0, 6) == "logout"){//==================================================polecnie logout
logowanie = false;
for(int i = 0; i<liczba_userow; i++)
tablica_userow[i].zalogowany = false;
}
else if(komenda.substr(0, 4) == "exit"){ //==============================================polecnie exit
logowanie = false;
wyjscie = true;  //podobne do powyzszego ale dodatkowo wyjscie = true
for(int i = 0; i<liczba_userow; i++)
tablica_userow[i].zalogowany = false;
}
else if(komenda.substr(0, 5) == "touch"){//==============================================polecenie touch
if(komenda.size() <= 6) //jesli nie podano parametru to wyswietli blad
cout << "touch: missing file operand" << endl;
else{
string plik = komenda.substr(6, (komenda.size()-5));
nowy_plik(plik);
}
}
else if(komenda.substr(0,2) == "rm"){//====================================================polecenie rm
if(komenda.size() <= 3) //jesli nie podano parametru to wyswietli blad
cout << "rm: missing operand" << endl;
else{
string plik = komenda.substr(3, (komenda.size()-3));
usun_plik(plik);
}
}
else if(komenda.substr(0, 2) == "ls" && komenda.size()==2){ //===========================polecenie ls
wyswietl_pliki(1, false); //ls
}
else if(komenda.substr(0, 6) == "ls -li" || komenda.substr(0, 6) == "ls -il"){
wyswietl_pliki(3, true); //ls -li
}
else if(komenda.substr(0, 5) == "ls -i"){
wyswietl_pliki(2, false); //ls -i
}
else if(komenda.substr(0, 5) == "ls -l"){
wyswietl_pliki(3, false); //ls -l
}

else if(komenda.substr(0, 5) == "umask"){ //============================================polecenie umask
if(komenda.size() == 5) //wyswietlanie umask
cout << umask.u << umask.g << umask.o << endl;
else { //zmienianie umask
string uTmp = komenda.substr(6, 1);
int uTmp2 = atoi(uTmp.c_str());
umask.u = uTmp2;
string gTmp = komenda.substr(7, 1);
int gTmp2 = atoi(gTmp.c_str());
umask.g = gTmp2;
string oTmp = komenda.substr(8, 1);
int oTmp2 = atoi(oTmp.c_str());
umask.o = oTmp2;
}
}

else if(komenda.substr(0, 7) == "adduser"){ //============================================polecenie adduser
if(komenda.size() == 7) //jesli nie podano parametru to wyswietli blad
cout << "adduser: missing operand, only one name allowed." << endl;
else{
string username = komenda.substr(8, (komenda.size()-7));
if(liczba_userow < rozmiar_userow){
if(zalogowany == 0){ //sprawdzanie czy uztkownik jest rootem
//username = komenda.substr(8, (komenda.size()-7));
int i = 0;
for(; i < liczba_userow; i++)
if( username == tablica_userow[i].nazwa)
break;
if( i == liczba_userow) // jesli i = liczbie userow, tzn. ze petla nie znalazla
dodaj_usera(username, true); //zadnego usera o podoanej nazwie, czyli mozna go utworzyc
else
cout << "adduser: The user '" << username << "' already exists." << endl;
} else
cout << "adduser: Only root may add a user o a group to the system." << endl;
} else {
if(czy_max_userow_i_jakis_usuniety())
dodaj_usera(username, false);
else
cout << "Maxium user number reached! Cannot create new user." << endl;
}
}
}//end of adduser

   else if(komenda.substr(0, 7) == "deluser"){ //============================================polecenie deluser
if(komenda.size() == 7) //jesli nie podano parametru to wyswietli blad
cout << "deluser: missing operand, only one name allowed." << endl;
else{
if(zalogowany == 0){ //sprawdzanie czy uztkownik jest rootem
string username = komenda.substr(8, (komenda.size()-7));
if(username != "root") { //nie mozna usuwac konta root (w tej implementacji)
int i = 0;
for(; i < liczba_userow; i++)
if( username == tablica_userow[i].nazwa){
usun_usera(username);
break;
}
if( i == liczba_userow ) //jesli for nie znajdzie usera o podanym loginie to znaczy, ze nie ma takiego
cout << "deluser: The user '" << username << "' does not exist." << endl; //i nie mozna go usunac
  } else
  cout << "WARING: You are just about to delete root account (uid 0)" << endl
   << "Ususally this is never required as it may render the whole system unusable" << endl
  << "Stopping now without having performed any action" << endl;
  }else
cout << "deluser: Only root may remove a user o a group from the system." << endl;
}
   }//end of deluser

else if(komenda.substr(0, 16) == "echo /etc/passwd"){//=============================polecenie do wyswietlania userow
wyswietl_userow();
}
else if(komenda.substr(0, 6) == "whoami"){ //=========================================polecenie whoami
cout << login << endl;
}
else if(komenda.substr(0,2) == "id"){ //==============================================polecenie id
cout << "uid=" << zalogowany << "(" << tablica_userow[zalogowany].nazwa << ") gid="
<< tablica_userow[zalogowany].GID << "(" << tablica_userow[zalogowany].grupa << ")" << endl;
}
else if(komenda.substr(0,5) == "chmod"){ //==============================================polecenie chmod
cout << "CHMOD" << endl;
}
else if(komenda.substr(0,5) == "chown"){ //==============================================polecenie chowm
if(zalogowany == 0){ //sprawdzanie czy uztkownik jest rootem
string username = komenda.substr(8, (komenda.size()-5));
cout << "CHOWN" << endl;
}
else{
cout << "chown: Operation not permitted" ;
}
}
else if(komenda.substr(0,5) == "chgrp"){ //==============================================polecenie chgrp
cout << "CHGRP" << endl;
}
else { //jesli bledna komenda
cout << komenda << ": " << "command not found" << endl;
}
}

//===============================================================init
void init(int * rozmiar, int * user){   
FILE * plik;
plik = fopen("config.txt", "r");
if(plik != NULL ){ //sprawdzenie czy plik istnieje
fscanf(plik, "%d", rozmiar);
fscanf(plik, "%d", user);
fclose(plik);
}
if(*rozmiar < 1) *rozmiar = 5;//podobne zabezpieczenie jak ponizej
if(*user < 1) *user = 1;//maks liczba userow musi byc przynajmniej 1, wiec jesli wpliku cos nie tak to
} //ustawiana na jeden bo przynajmniej root musi istniec

//===============================================================wyczysc
void wyczysc(){ //zwalnia pamiec przeznaczona na
katalog * tmp; //liste plikow
while(pierwszy){
tmp = pierwszy;
pierwszy = pierwszy->next_el; // pierwszy = drugi, czyli przesuwamy
delete tmp;   // poczatek o jedno miejsce
}
delete[] tablica_inodow;
delete[] tablica_userow;
}

int _tmain(int argc, _TCHAR* argv[])
{
init(&rozmiar_inodow, &rozmiar_userow); //pobieranie maksymalnej liczby userow i inodow
cout << "Maximum file number:" << rozmiar_inodow << " " << "Maximum user number:" << rozmiar_userow << endl << endl;

//===============================================================umask
umask.u = 0;  //domyslna wartosc umask
umask.g = 0;
umask.o = 2;

liczba_inodow = 0; //poczatkowa liczba inodow
tablica_inodow = new inode [rozmiar_inodow];
liczba_plikow = 0;
pierwszy = NULL;

//===============================================================uzytkownicy
tablica_userow = new user [rozmiar_userow];

root.nazwa = "root";
root.GID = 0; //przypisanie roota do root (zmienna grupa1)
root.grupa = "root";
root.zalogowany = false;
tablica_userow[0] = root;
liczba_userow = 1;

//===============================================================grupy
grupa1.nazwa = "root";
grupa2.nazwa = "grupa2";
grupa3.nazwa = "grupa3";

tablica_grup[0] = grupa1;
tablica_grup[1] = grupa2; //userzy o UID nieparzystym
tablica_grup[2] = grupa3; //userzy o UID parzystym

//===============================================================petla programu
while(!wyjscie){
logowanie = zaloguj();
while(logowanie){
pobierz_komende();
}
}

wyczysc();
return 0;
}

jak skończę to wrzucę całość, może kiedyś komuś coś takiego się przyda ;p
« Ostatnia zmiana: Grudzień 16, 2011, 19:48:26 wysłana przez Abik »

Abik

Odp: Cout podwójnie wyświetla
« Odpowiedź #2 dnia: Grudzień 17, 2011, 19:09:16 »
Dobra, to jest już koniec:
#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <conio.h>
#include <string>
#include <Windows.h>
using namespace std;

HANDLE okno;

//===============================================================struktury danych
struct inode{
int u;
int g;
int o;
int UID;
int GID;
bool exec;
bool usuniety;
};

struct usermask{
int u;
int g;
int o;
};

struct katalog{
string nazwa;
int numer_inoda;
katalog * next_el;
};

struct user{
string nazwa;
int GID; //do jakiej grupy nalezy
string grupa; //nazwa tej grupy
bool zalogowany;
};

struct group{
string nazwa;
};

//=================================================================zmienne globalne
string login;
bool logowanie;
bool wyjscie = false;
int zalogowany;

inode * tablica_inodow;
katalog * pierwszy;
usermask umask;

int rozmiar_inodow; //maksymalna liczba tworzona dynamicznie z pliku config.txt
int liczba_inodow; //liczba aktualnie istniejacych inodow stworzonych w funkcji nowy_plik
int liczba_plikow; //praktycznie liczba pozycji na liscie w katalogu

int rozmiar_userow; //analogiczna sytuacja
int liczba_userow; //jak dla inodow

//grupy i uzytkownicy
user * tablica_userow;
user root;

group tablica_grup[3];
group grupa1; //grupa dla roota
group grupa2; //grupa dla userow o UID nieparzystym
group grupa3; //grupa dla userow o UID parzystym

//================================================================podziel
void podziel(string * str, string * str2){
for(unsigned int i = 0; i < str->size(); i++){
if(str->substr(i, 1) == " "){
(*str2) = str->substr(i+1, str->size());
(*str) = str->substr(0, i);
break;
}
}
}

//================================================================istnieje
bool istnieje(string plik){
katalog * tmp = pierwszy;

while(tmp){
if(tmp->nazwa == plik)
return true;
tmp = tmp->next_el;
}
return false;
}

//================================================================wykonywalny
bool wykonywalny(string plik){
katalog * tmp = pierwszy;

while(tmp){
if(tmp->nazwa == plik){
if(tablica_inodow[tmp->numer_inoda].exec) //jesli wykonywalny
return true;   //to zwraca true
}
tmp = tmp->next_el;
}
return false;
}

//================================================================push
void dodaj(string nazwa, int inode_number){
katalog *nowy = new katalog;
katalog *tmp1 = pierwszy;
katalog *tmp2 = NULL;

nowy->nazwa = nazwa;
nowy->numer_inoda = inode_number;

while(tmp1 != NULL){
tmp2 = tmp1; //tmp zawsze jest poprzednikiem tmp1
tmp1 = tmp1->next_el;
}
if(pierwszy == NULL){
nowy->next_el = pierwszy;
pierwszy = nowy;
} else {
tmp2->next_el = nowy;
nowy->next_el = tmp1;
}
}

//===============================================================czy_max_plikow
int czy_max_plikow_i_jakis_usuniety(){
int usuniety = 0;
if(liczba_plikow != liczba_inodow){
for(; usuniety < liczba_inodow; usuniety++){
if(tablica_inodow[usuniety].usuniety == true)
return usuniety;
}
} else {
if(liczba_inodow == rozmiar_inodow)
return -2;
else
return -1;
}
}


//===============================================================nowy_plik
void nowy_plik(string plik){  //ma pobierac nazwe pliku i tworzyc nowy element na liscie i odpowiadajacego jej inoda
if(istnieje(plik))
cout << "File '" << plik << "' already exist" << endl;
else{
inode inodeTmp;
inodeTmp.usuniety = false;

inodeTmp.u = 6 - umask.u;
if(inodeTmp.u < 0) inodeTmp.u = 0;
inodeTmp.g = 6 - umask.g;
if(inodeTmp.g < 0) inodeTmp.g = 0;
inodeTmp.o = 6 - umask.o;
if(inodeTmp.o < 0) inodeTmp.o = 0;

if(plik.size() > 3){ //zeby nie sprawdzal czy jest rozszerzenie jesli nazwa pliku jest
if((plik.substr(plik.size()-3, plik.size()) == "elf")) //mniejsza niz dlugosc rozszerzenia
inodeTmp.exec = true;
else
inodeTmp.exec = false;
}
inodeTmp.UID = zalogowany; //przypisanie wlasciciela
inodeTmp.GID = tablica_userow[zalogowany].GID; //przypisanie grupy

int nr_wolnego_inoda = czy_max_plikow_i_jakis_usuniety();
if(nr_wolnego_inoda == -1){
tablica_inodow[liczba_inodow] = inodeTmp;//dodaje inoda do tablicy
dodaj(plik, liczba_inodow);//wpis do listy plikow - katalogu

liczba_plikow++;
liczba_inodow++; //zwiekszamy dopiero tutaj, zeby nr inoda zgadzal sie z tym zapisanym na liscie plikow
}
else if(nr_wolnego_inoda >= 0){
tablica_inodow[nr_wolnego_inoda] = inodeTmp;//dodaje inoda do tablicy
dodaj(plik, nr_wolnego_inoda);//wpis do listy plikow - katalogu

liczba_plikow++;
}
else if(nr_wolnego_inoda == -2)
cout << "Cannot create file: No free disc space available." << endl;
}
}


//===============================================================usun_plik
void usun_plik(string plik){
katalog * tmp = pierwszy;
katalog * tmp2;
int test = 0; //jesli wartosc tej zmiennej bedzie taka
  //jak liczba plikow w systemie, tzn. ze plik nie istnieje
while(tmp){
if(tmp->nazwa == plik){
tablica_inodow[tmp->numer_inoda].usuniety = true;
tmp2->next_el = tmp->next_el;
delete tmp;
liczba_plikow--;
break;
}
tmp2 = tmp; //tmp2 jest zawsze poprzednikiem tmp
tmp = tmp->next_el;
test++;
}
if(test == liczba_plikow)
cout << "rm: cannot remove '" << plik << "': No such file" << endl;
}

//===============================================================wyswietl_pliki
void wyswietl_pliki(int przelacznik, bool il){
katalog * tmp = pierwszy;

if(przelacznik == 1){ //ls
while(tmp){
cout << tmp->nazwa << " ";
tmp = tmp->next_el;
}
cout << endl;
}
if(przelacznik == 2){//ls -i
while(tmp){
cout << tmp->numer_inoda << " " << tmp->nazwa << " ";
tmp = tmp->next_el;
}
cout << endl;
}
if(przelacznik == 3){
while(tmp){
int tmpNum = tmp->numer_inoda;
int userID = tablica_inodow[tmpNum].UID;
int groupID = tablica_inodow[tmpNum].GID;

if(il)
cout << tmp->numer_inoda << " ";
cout << "-"; //typ pliku, tutaj zawsze zwykly plik
switch(tablica_inodow[tmpNum].u){ //uprawnienia wlasciciela
case 6: cout << "rw-"; break; //rw
case 5: cout << "r-x"; break; //rx
case 3: cout << "-wx"; break; //wx
case 4: cout << "r--"; break; //r
case 2: cout << "-w-"; break; //w
case 1: cout << "--x"; break; //x
case 7: cout << "rwx"; break; //rwx
case 0: cout << "---"; break;
}
switch(tablica_inodow[tmpNum].g){ //uprawnienia grupy
case 6: cout << "rw-"; break; //rw
case 5: cout << "r-x"; break; //rx
case 3: cout << "-wx"; break; //wx
case 4: cout << "r--"; break; //r
case 2: cout << "-w-"; break; //w
case 1: cout << "--x"; break; //x
case 7: cout << "rwx"; break; //rwx
case 0: cout << "---"; break;
}
switch(tablica_inodow[tmpNum].o){ //uprawnienia innych
case 6: cout << "rw-"; break; //rw
case 5: cout << "r-x"; break; //rx
case 3: cout << "-wx"; break; //wx
case 4: cout << "r--"; break; //r
case 2: cout << "-w-"; break; //w
case 1: cout << "--x"; break; //x
case 7: cout << "rwx"; break; //rwx
case 0: cout << "---"; break;
}
cout << " " << "1" << " " //dowiazania do pliku, tutaj zawsze 1
<< tablica_userow[userID].nazwa << " " //wyswietla wlasciciela
<< tablica_grup[groupID].nazwa << " " //wyswietla grupe
<< "0" << " " //wielkosc pliku w bajtach
<< tmp->nazwa << endl; //tutaj jeszcze wyswietlic nazwe pliku
tmp = tmp->next_el; //przesuwamy sie na nastepny plik
}
}
}

//===============================================================zmien_tryb
void zmien_tryb(string tryb, string plik){
int tmpInumber = 0;
katalog * tmp = pierwszy;

while(tmp){ //szukamy numeru inoda naszego pliku
if(tmp->nazwa == plik){ //bo tam jest info o wlascicielu
tmpInumber = tmp->numer_inoda;
break;
}
tmp = tmp->next_el;
}

if(istnieje(plik)){
if((zalogowany == 0) || (zalogowany == tablica_inodow[tmp->numer_inoda].UID)){ //mozna zmienic tryb tylko jesi
if(tryb.size() == 3){    //jest sie rootem albo wlascicielem
string uTmp = tryb.substr(0, 1);    
int uTmp2 = atoi(uTmp.c_str());
if(uTmp2 > 7) uTmp2 = 7; //zabezpieczenie aby nie
if(uTmp2 < 0) uTmp2 = 0; //przekroczyc zakresu
tablica_inodow[tmp->numer_inoda].u = uTmp2;

string gTmp = tryb.substr(1, 1);
int gTmp2 = atoi(gTmp.c_str());
if(uTmp2 > 7) uTmp2 = 7;
if(uTmp2 < 0) uTmp2 = 0;
tablica_inodow[tmp->numer_inoda].g = gTmp2;

string oTmp = tryb.substr(2, 1);    
int oTmp2 = atoi(oTmp.c_str());
if(uTmp2 > 7) uTmp2 = 7;
if(uTmp2 < 0) uTmp2 = 0;
tablica_inodow[tmp->numer_inoda].o = oTmp2;
}
else
cout << "chmod: invalid mode: '" << tryb << "'" << endl;
}
else
cout << "chmod: changing permission of file '" << plik << "': Operation not permitted" << endl;
}
else
cout << "chmod: cannot access '" << plik << "': No such file"  << endl;
}

//===============================================================zmien_wlasciciela
void zmien_wlasciciela(string user, string plik){
int tmpUID = 0;
int tmpInumber = 0;
katalog * tmp = pierwszy;

while(tmp){ //szukamy numeru inoda naszego pliku
if(tmp->nazwa == plik){ //bo tam jest info o wlascicielu
tmpInumber = tmp->numer_inoda;
break;
}
tmp = tmp->next_el;
}
for(; tmpUID < liczba_userow; tmpUID++){ //szukamy UID usera bo ono
if(tablica_userow[tmpUID].nazwa == user){ //musi byc zapisane w inodzie
break;
}
}
if(tmpUID == liczba_userow) //sprawdzamy czy podany user istnieje
cout << "chown: invalid user '" << user <<"'" << endl;
else{
if(istnieje(plik)) //sprawdzamy czy plik istnieje
tablica_inodow[tmpInumber].UID = tmpUID;
else
cout << "chown: cannot access '" << plik << "': No such file"  << endl;
}
}

//===============================================================zmien_grupe
void zmien_grupe(string grupa, string plik){
int tmpGID = 0;
int tmpInumber = 0;
katalog * tmp = pierwszy;

while(tmp){ //szukamy numeru inoda naszego pliku
if(tmp->nazwa == plik){ //bo tam jest info o grupie
tmpInumber = tmp->numer_inoda;
break;
}
tmp = tmp->next_el;
}
for(; tmpGID < 3; tmpGID++){ //szukamy UID usera bo ono
if(tablica_grup[tmpGID].nazwa == grupa){ //musi byc zapisane w inodzie
break;
}
}
if(istnieje(plik)){ //sprawdzamy czy plik istnieje
if(tmpGID == 3) //sprawdzenie czy grupa istnieje
cout << "chown: invalid group '" << grupa <<"'" << endl;
else{
if((zalogowany == tablica_inodow[tmpInumber].UID) || (zalogowany == 0)) //sprawdzamy czy user jest
tablica_inodow[tmpInumber].GID = tmpGID; //wlascicielem albo rootem
else
cout << "chgrp: changing group of '" << grupa << "': Operation not permitted" << endl;
}
}
else
cout << "chgrp: cannot access '" << plik << "': No such file"  << endl;
}

//===============================================================sprawdz_prawa
bool sprawdz_prawa(string plik, int rwx){ //r-1, w-2, x-3
//nie sprawdzamy czy plik istnieje bo ta funkcja wykonywana tylko
//gdy plik istnieje
if(zalogowany == 0) return true; //jesli root, to ma prawo do wszystkiego

katalog * tmp = pierwszy;
int tmpInumber = 0;

while(tmp){ //szukamy numeru inoda naszego pliku
if(tmp->nazwa == plik){ //bo tam jest info o prawach
tmpInumber = tmp->numer_inoda;
break;
}
tmp = tmp->next_el;
}
//sprawdzaie prawa R ... 7,6,5,4
if(rwx == 1){
if(tablica_inodow[tmpInumber].o >= 4)
return true; //uprawnienie R dla wszystkich
if(tablica_userow[zalogowany].GID == tablica_inodow[tmpInumber].GID)
if(tablica_inodow[tmpInumber].g >= 4)
return true; //uprawnienie R dla grupy
if(zalogowany == tablica_inodow[tmpInumber].UID)
if(tablica_inodow[tmpInumber].u >= 4)
return true; //uprawnienie R dla wlasciciela
}
//sprawdzanie prawa W ... 7,6,3,2
if(rwx == 2){
cout << "IF RWX = 2" << endl;
if(tablica_inodow[tmpInumber].o >= 6 || tablica_inodow[tmpInumber].o == 3 || tablica_inodow[tmpInumber].o == 2)
return true; //uprawnienie W dla wszystkich
if(tablica_userow[zalogowany].GID == tablica_inodow[tmpInumber].GID)
if(tablica_inodow[tmpInumber].g >= 6 || tablica_inodow[tmpInumber].g == 3 || tablica_inodow[tmpInumber].g == 2)
return true; //uprawnienie W dla grupy
if(zalogowany == tablica_inodow[tmpInumber].UID)
if(tablica_inodow[tmpInumber].u >= 6 || tablica_inodow[tmpInumber].u == 3 || tablica_inodow[tmpInumber].u == 2)
return true; //uprawnienie W dla wlasciciela
}
//sprawdzanie prawa X 7,5,3,1
if(rwx == 3){
if(tablica_inodow[tmpInumber].o == 7 || tablica_inodow[tmpInumber].o == 5 ||
tablica_inodow[tmpInumber].o == 3 || tablica_inodow[tmpInumber].o == 1)
return true; //uprawnienie X dla wszystkich
if(tablica_userow[zalogowany].GID == tablica_inodow[tmpInumber].GID)
if(tablica_inodow[tmpInumber].g == 7 || tablica_inodow[tmpInumber].g == 5 ||
tablica_inodow[tmpInumber].g == 3 || tablica_inodow[tmpInumber].g == 1)
return true; //uprawnienie X dla grupy
if(zalogowany == tablica_inodow[tmpInumber].UID)
if(tablica_inodow[tmpInumber].u == 7 || tablica_inodow[tmpInumber].u == 5 ||
tablica_inodow[tmpInumber].u == 3 || tablica_inodow[tmpInumber].u == 1)
return true; //uprawnienie X dla wlasciciela
}
return false;
}

//===============================================================zaloguj
bool zaloguj(){
cout << "login: ";
getline(cin, login);

if(login != "---"){
int i = 0;
for(; i < liczba_userow; i++){
if(login == tablica_userow[i].nazwa){
tablica_userow[i].zalogowany = true;
zalogowany = i; //zapamietywanie jaki user jest zalogowany
break; //wyjscie z petli jesli udalo sie zalogowac
}
}
if(i == liczba_userow){
cout << "Login incorrect" << endl;
return false;
}
}
else {
cout << "Login incorrect" << endl;
return false;
}
return true;
}

//===============================================================dodaj_usera
void dodaj_usera(string username, bool zwieksz_liczbe_userow){ //UID nowego usera = akutalna wartosc
user userTmp; //zmiennej liczba userow!
userTmp.nazwa = username;
if((liczba_userow % 2) == 0){ //jesli ma parzyste UID to do grupy3
userTmp.GID = 2;
userTmp.grupa = "grupa3";
}
else { //jesli nieparzyste UID to do grupy2
userTmp.GID = 1;
userTmp.grupa = "grupa2";
}
userTmp.zalogowany = false;

if(zwieksz_liczbe_userow){ //liczba ta nie moze byc zwiekszana, jesli dodawani sa nowi
tablica_userow[liczba_userow] = userTmp; //uzytkownicy na pozycjach userow usunietych
liczba_userow++;  
}
else{
for(int i = 0; i < liczba_userow; i++){ //jesli tablica jest pelna, ale sa w niej usunieci userzy
if(tablica_userow[i].nazwa == "---"){//to wtedy w tej petl1i sa oni znajdowani i zastepowani
if((i%2) == 0){ //nowo tworzonym userem
userTmp.GID = 2;
userTmp.grupa = "grupa3";
}
tablica_userow[i] = userTmp;
break;
}
}
}
}

//===============================================================usun_usera
void usun_usera(string username){
for(int i = 0; i < liczba_userow; i++){
if(tablica_userow[i].nazwa == username){
tablica_userow[i].nazwa = "---";
tablica_userow[i].grupa = "---";
tablica_userow[i].GID = -1;
}
}
}

//===============================================================wyswietlanie_userow
void wyswietl_userow(){ //format: nazwa_usera:haslo-x:UID:GID:nazwa_grupy:katalog_domowy ~
for(int i = 0; i < liczba_userow; i++)
if(tablica_userow[i].nazwa != "---")//nie wyswietlac usunietych userow
cout << tablica_userow[i].nazwa << ":x:" << i << ":" << tablica_userow[i].GID << ":" << tablica_userow[i].grupa << ":" << "~" <<endl;
}

//===============================================================czlonek_grupy
bool czlonek_grupy(int UID, string grupa){
if(tablica_userow[UID].grupa == grupa)
return true;
return false;
}


//===============================================================czy_max_userow
bool czy_max_userow_i_jakis_usuniety(){
int usuniety = 0; //to ostatecznie bedzie indeks pierwszego usunietego usera
for(; usuniety < liczba_userow; usuniety++){
if(tablica_userow[usuniety].nazwa == "---")
break;
}
if((liczba_userow == rozmiar_userow) && (usuniety < liczba_userow)) return true;
else return false;
}

//===============================================================pobierz_komende
void pobierz_komende(){
if(zalogowany == 0){ //rozne znaki zachety dla roota i zwyklych userow
SetConsoleTextAttribute(okno, 12); //niebieski
cout << login;
SetConsoleTextAttribute(okno, 7); //szary
cout << ": ";
SetConsoleTextAttribute(okno, 9); //niebieski
cout << "~";
SetConsoleTextAttribute(okno, 7); //szary
cout << "# ";
}
else{
SetConsoleTextAttribute(okno, 2); //zielony
cout << login;
SetConsoleTextAttribute(okno, 7); //szary
cout << ": ";
SetConsoleTextAttribute(okno, 2); //zielonu
cout << "~";
SetConsoleTextAttribute(okno, 7); //szary
cout << "$ ";
}
string komenda;
getline(cin, komenda);

if(komenda.substr(0, 6) == "logout"){//==================================================polecnie logout
logowanie = false;
for(int i = 0; i<liczba_userow; i++)
tablica_userow[i].zalogowany = false;
}
else if(komenda.substr(0, 4) == "exit"){ //==============================================polecnie exit
logowanie = false;
wyjscie = true;  //podobne do powyzszego ale dodatkowo wyjscie = true
for(int i = 0; i<liczba_userow; i++)
tablica_userow[i].zalogowany = false;
}
else if(komenda.substr(0, 5) == "touch"){//==============================================polecenie touch
if(komenda.size() <= 6) //jesli nie podano parametru to wyswietli blad
cout << "touch: missing file operand" << endl;
else{
string plik = komenda.substr(6, (komenda.size()-5));
nowy_plik(plik);
}
}
else if(komenda.substr(0,2) == "rm"){//====================================================polecenie rm
if(komenda.size() <= 3) //jesli nie podano parametru to wyswietli blad
cout << "rm: missing operand" << endl;
else{
string plik = komenda.substr(3, (komenda.size()-3));
usun_plik(plik);
}
}
else if(komenda.substr(0, 2) == "ls" && komenda.size()==2){ //===========================polecenie ls
wyswietl_pliki(1, false); //ls
}
else if(komenda.substr(0, 6) == "ls -li" || komenda.substr(0, 6) == "ls -il"){
wyswietl_pliki(3, true); //ls -li
}
else if(komenda.substr(0, 5) == "ls -i"){
wyswietl_pliki(2, false); //ls -i
}
else if(komenda.substr(0, 5) == "ls -l"){
wyswietl_pliki(3, false); //ls -l
}

else if(komenda.substr(0, 5) == "umask"){ //============================================polecenie umask
if(komenda.size() == 5) //wyswietlanie umask
cout << umask.u << umask.g << umask.o << endl;
else { //zmienianie umask
string uTmp = komenda.substr(6, 1);
int uTmp2 = atoi(uTmp.c_str());
umask.u = uTmp2;
string gTmp = komenda.substr(7, 1);
int gTmp2 = atoi(gTmp.c_str());
umask.g = gTmp2;
string oTmp = komenda.substr(8, 1);
int oTmp2 = atoi(oTmp.c_str());
umask.o = oTmp2;
}
}

else if(komenda.substr(0, 7) == "adduser"){ //============================================polecenie adduser
if(komenda.size() == 7) //jesli nie podano parametru to wyswietli blad
cout << "adduser: missing operand, only one name allowed." << endl;
else{
string username = komenda.substr(8, (komenda.size()-7));
if(liczba_userow < rozmiar_userow){
if(zalogowany == 0){ //sprawdzanie czy uztkownik jest rootem
//username = komenda.substr(8, (komenda.size()-7));
int i = 0;
for(; i < liczba_userow; i++)
if( username == tablica_userow[i].nazwa)
break;
if( i == liczba_userow) // jesli i = liczbie userow, tzn. ze petla nie znalazla
dodaj_usera(username, true); //zadnego usera o podoanej nazwie, czyli mozna go utworzyc
else
cout << "adduser: The user '" << username << "' already exists." << endl;
} else
cout << "adduser: Only root may add a user o a group to the system." << endl;
} else {
if(czy_max_userow_i_jakis_usuniety())
dodaj_usera(username, false);
else
cout << "Maxium user number reached! Cannot create new user." << endl;
}
}
}//end of adduser

   else if(komenda.substr(0, 7) == "deluser"){ //============================================polecenie deluser
if(komenda.size() == 7) //jesli nie podano parametru to wyswietli blad
cout << "deluser: missing operand, only one name allowed." << endl;
else{
if(zalogowany == 0){ //sprawdzanie czy uztkownik jest rootem
string username = komenda.substr(8, (komenda.size()-7));
if(username != "root") { //nie mozna usuwac konta root (w tej implementacji)
int i = 0;
for(; i < liczba_userow; i++)
if( username == tablica_userow[i].nazwa){
usun_usera(username);
break;
}
if( i == liczba_userow ) //jesli for nie znajdzie usera o podanym loginie to znaczy, ze nie ma takiego
cout << "deluser: The user '" << username << "' does not exist." << endl; //i nie mozna go usunac
  } else
  cout << "WARING: You are just about to delete root account (uid 0)" << endl
   << "Ususally this is never required as it may render the whole system unusable" << endl
  << "Stopping now without having performed any action" << endl;
  }else
cout << "deluser: Only root may remove a user o a group from the system." << endl;
}
   }//end of deluser

else if(komenda.substr(0, 16) == "echo /etc/passwd"){//=============================polecenie do wyswietlania userow
wyswietl_userow();
}
else if(komenda.substr(0, 6) == "whoami"){ //=========================================polecenie whoami
cout << login << endl;
}
else if(komenda.substr(0,2) == "id"){ //==============================================polecenie id
cout << "uid=" << zalogowany << "(" << tablica_userow[zalogowany].nazwa << ") gid="
<< tablica_userow[zalogowany].GID << "(" << tablica_userow[zalogowany].grupa << ")" << endl;
}
else if(komenda.substr(0,5) == "chmod"){ //==============================================polecenie chmod
if(!(komenda.size() == 5)){
//sprawdzic czy user jest wlascicielem pliku!!!!!!!!!!!!!!!!!!!!
string part2 = komenda.substr(6, (komenda.size()-5));
string part3 = " ";
podziel(&part2, &part3);
zmien_tryb(part2, part3); //chmod xxx plik
}
else
cout << "chmod: missing operand" << endl;
}
else if(komenda.substr(0,5) == "chown"){ //==============================================polecenie chown
if(zalogowany == 0){ //sprawdzanie czy uztkownik jest rootem
if(!(komenda.size() == 5)){ //jesli brak parametrow to wyswietli blad
string part2 = komenda.substr(6, (komenda.size()-5));
string part3 = " ";
podziel(&part2, &part3); //to sa argumenty in-out
zmien_wlasciciela(part2, part3); //chown user plik
}
else
cout << "chown: missing operand" << endl;
}
else{
cout << "chown: Operation not permitted" ;
}
}
else if(komenda.substr(0,5) == "chgrp"){ //==============================================polecenie chgrp
if(!(komenda.size() == 5)){ //jesli brak param. to wyswietli blad
string part2 = komenda.substr(6, (komenda.size()-5));
string part3 = " ";
podziel(&part2, &part3); //chgrp grupa plik
if(czlonek_grupy(zalogowany, part2)) //sprawdzamy czy user jest czlonkiem grupy do ktorej chce przypisac plik
zmien_grupe(part2, part3); //chgrp grupa plik
else{ //jesli nie jest czlonkiem nowej grupy to moze byc rootem, jak nie jest to wyswietla blad
if(zalogowany == 0)
zmien_grupe(part2, part3);
else
cout << "chgrp: changing group of '" << part3 << "': Operation not permitted" << endl;
}
}
else
cout << "chgrp: missing operand" << endl;
}
else if(komenda.substr(0,3) == "cat"){//===============================================polecenie cat
if(komenda.size()>4){
string plik = komenda.substr(4, komenda.size()-3);
if(istnieje(plik))
if(sprawdz_prawa(plik, 1))
cout << "Content of file: " << plik << endl;
else
cout << "cat: operation not permitted" << endl;
else
cout << "cat: file '" << plik << "' not found" << endl;
}
}
else if(komenda.substr(0,4) == "edit"){//==============================================polecenie edit
if(komenda.size()>5){
string plik = komenda.substr(5, komenda.size()-4);
if(istnieje(plik))
if(sprawdz_prawa(plik, 2))
cout << "Now editting: " << plik << endl;
else
cout << "edit: operation not permitted" << endl;
else
cout << "edit: file '" << plik << "' not found" << endl;
}
}
else if(komenda.substr(0,2) == "./"){//================================uruchamianie plikow wykonywalnych
if(komenda.size()>=2){
string plik = komenda.substr(2, komenda.size()-2);
if(istnieje(plik))
if(wykonywalny(plik))
if(sprawdz_prawa(plik,3))
cout << "Now executing: " << plik << endl;
else
cout << "edit: operation not permitted" << endl;
else
cout << "file '" << plik << "' cannot be executed" << endl;
else
cout << "file '" << plik << "' not found" << endl;
}
}
else if(komenda.substr(0,4) == "help"){//============================================wyswietlanie helpa
ifstream plik("help.txt");
string tmp;

if(!plik.is_open())
cout << "File help.txt does not exist" << endl;
else
while(getline(plik, tmp))
cout << tmp << endl;

plik.close();
}
else { //jesli bledna komenda
cout << komenda << ": " << "command not found" << endl;
}
}

//===============================================================init
void init(int * rozmiar, int * user){   
FILE * plik;
plik = fopen("config.txt", "r");
if(plik != NULL ){ //sprawdzenie czy plik istnieje
fscanf(plik, "%d", rozmiar);
fscanf(plik, "%d", user);
fclose(plik);
}
if(*rozmiar < 1) *rozmiar = 5;//podobne zabezpieczenie jak ponizej
if(*user < 1) *user = 1;//maks liczba userow musi byc przynajmniej 1, wiec jesli wpliku cos nie tak to
} //ustawiana na jeden bo przynajmniej root musi istniec

//===============================================================wyczysc
void wyczysc(){ //zwalnia pamiec przeznaczona na
katalog * tmp; //liste plikow
while(pierwszy){
tmp = pierwszy;
pierwszy = pierwszy->next_el; // pierwszy = drugi, czyli przesuwamy
delete tmp;   // poczatek o jedno miejsce
}
delete[] tablica_inodow;
delete[] tablica_userow;
}

int _tmain(int argc, _TCHAR* argv[])
{
okno = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(okno, 7); //szary

init(&rozmiar_inodow, &rozmiar_userow); //pobieranie maksymalnej liczby userow i inodow

cout << "Maximum file number:";
SetConsoleTextAttribute(okno, 2); //zielony
cout << rozmiar_inodow;
SetConsoleTextAttribute(okno, 7); //szary
cout << " " << "Maximum user number:";
SetConsoleTextAttribute(okno, 2); //zielony
cout << rozmiar_userow << endl << endl;
SetConsoleTextAttribute(okno, 7); //szary

//===============================================================umask
umask.u = 0;  //domyslna wartosc umask
umask.g = 0;
umask.o = 2;

liczba_inodow = 0; //poczatkowa liczba inodow
tablica_inodow = new inode [rozmiar_inodow];
liczba_plikow = 0;
pierwszy = NULL;

//===============================================================uzytkownicy
tablica_userow = new user [rozmiar_userow];

root.nazwa = "root";
root.GID = 0; //przypisanie roota do root (zmienna grupa1)
root.grupa = "root";
root.zalogowany = false;
tablica_userow[0] = root;
liczba_userow = 1;

//===============================================================grupy
grupa1.nazwa = "root";
grupa2.nazwa = "grupa2";
grupa3.nazwa = "grupa3";

tablica_grup[0] = grupa1;
tablica_grup[1] = grupa2; //userzy o UID nieparzystym
tablica_grup[2] = grupa3; //userzy o UID parzystym

//===============================================================petla programu
while(!wyjscie){
logowanie = zaloguj();
while(logowanie){
pobierz_komende();
}
}

wyczysc();
return 0;
}
żeby była jasność w ogóle wtf?
na zal z labów miałem temat "uprawnienia do plików w systemie unix", no i miałem jakoś zaimplementować rozwiązanie tego "problemu" w c lub c++ ... no i to jest właśnie to.
w praktyce to działa trochę jak unixowa/linuxowa konsola, pobiera komendy i je wykonuje... ilość komend ograniczona oczywiście do zbioru niezbędnego aby pobawić się i pokombinować z uprawnieniami...
tutaj jest niestety tylko jeden katalog (bo nie kazał kolo robić więcej, szkoda : D ale ja nie będę nadgorliwy), ale rozszerzyć to do większej liczby nie byłoby jakoś strasznie trudno, trzeba by tylko robić nowe listy typu katalog, dorobić polecenie cd i przerobić funkcje tak żeby były świadome z jakiego katalogu korzystają : P
kod jest generalnie bardzo brzydki bo na spontanie to pisałem, co mi przyszło do głowy to robiłem, bez większego przemyślenia, niektóre fragmenty się gdzieś tam nawet powtarzają, nie dużo, ale ździebko : P
tak czy siak działa i w praktyce może komuś posłużyć do ogarnięcia podstaw uprawnień do plików na unixie, ale i tak nie polecam, wrzucam jak ktoś może kiedyś coś takiego potrzebował : P
pozdro :D
« Ostatnia zmiana: Grudzień 21, 2011, 21:28:46 wysłana przez Abik »