milis/bin/mps

#!/bin/bash

versiyon="1.1.9 Milis Paket Sistemi"
iletisim="milisarge@gmail.com"

betikad=${0##*/}
betikyol="$0"
shelltip=$(basename `cat $betikyol | head -n1 | cut -d'!' -f2 | cut -d' ' -f1`)

# sistem araçlarının tespiti ve atanması
#if [ ${shelltip} = "busybox" ] || [ ${shelltip} = "ash" ];then
if [ ${BASH_VERSION} ];then
	wget_progress="--show-progress"
else
	alias sed="busybox sed"
	alias wget="busybox wget"
	wget_progress=""
fi
#alias sed="sed"

if [ -f /etc/mps.conf ];then
. /etc/mps.conf
else
	echo "/etc/mps.conf ayar dosyası bulunamadı!"
fi

if [ -z ${paketdepo+:} ]; then
	paketdepo="/depo/paketler/"
fi

if [ -z ${sunucu+:} ]; then
	sunucu="127.0.0.1:8000/"
fi

if [ -z ${git_sunucu+:} ]; then
	git_sunucu="https://github.com/milisarge/malfs-milis"
fi

if [ -z ${git_depo+:} ]; then
	git_depo="/sources/milis.git"
fi

if [ -z ${kaynak_dizin+:} ]; then
	kaynak_dizin="/sources"
fi

if [ -z ${anatalimatname+:} ]; then
	anatalimatname="${git_depo}/talimatname"
fi

if [ -z ${talimatname+:} ]; then
	talimatname="/root/talimatname"
fi

if [ -z ${kokdizin+:} ]; then
	kokdizin="/"
fi

#temel paket koruma
if [ -z ${tpk+:} ]; then
	tpk="evet"
fi
if [ -z ${lokal+:} ]; then
	lokal="tr"
fi
if [ -z ${docsil+:} ]; then
	docsil="evet"
fi
if [ -z ${yerelsil+:} ]; then
	yerelsil="silme"
fi
if [ -z ${ektalimatname+:} ]; then
	ektalimatname="/root/talimatlar"
	[ ! -d /root/talimatlar ] && mkdir -p /root/talimatlar
fi

if [ -z ${sunucular+:} ]; then
	sunucular="paketler.milislinux.org"
	awk ' {print;} NR == 1 { print "sunucular=\"paketler.milislinux.org/\""; }' /etc/mps.conf > /etc/mps2.conf
	mv /etc/mps2.conf /etc/mps.conf
else
	_satirno=$(grep -nr "sunucular=(" /etc/mps.conf | cut -d':' -f1)
	if [ ! -z ${_satirno} ];then
		echo "mps.conf düzeltildi.kontrol ediniz."
		sed "${_satirno}s/(/"\""/;${_satirno}s/)/"\""/" /etc/mps.conf > /etc/mps.conf.yeni
		mv /etc/mps.conf.yeni /etc/mps.conf
	fi
fi

if [ -z ${silme_esgec+:} ]; then
	silme_esgec=""
fi

if [ -z ${esgec+:} ]; then
	esgec=""
fi

esgec="xorg xorg-app xorg-font xorg-proto kernel-lts kernel-lts-src"

kurulum_onay="evet"

VT="/var/lib/pkg/DB"
TARIHCE_DIZIN="/var/lib/pkg/tarihce"
LOGDIZIN="/var/log/mps"
tekrarkur="hayir"
logdosya="/var/log/mps/mps.log"

# Türkçe Mesajlar
_paket_adi_gerekli="paket ismi eksik!"
_dizin_bulunamadi="dizin bulunamadı!"
_talimat_sayisi_fazla="talimatnameler altında birden fazla talimat mevcut!"
_talimat_bulunamadi="ilgili talimat bulunamadı!"
_talimatsiz_dizin="ilgili dizinde talimat bulunamadı!"
_dosya_yolu_bulunamadi="dosya yolu bulunamadı!"
_shasum_uyumsuzluk="shasum uyumsuzluğu tespit edildi!"
_gerekler_belirleniyor="bağımlılıkları belirleniyor."
_yerel_paket_yok="mevcut dizinde mps.lz paketi yok!"
_paket_kuruldu="paketi kuruldu."
_paket_kurulu="kurulu"
_paket_kurulu_degil="paketi kurulu değil!"
_paket_silindi="paketi silindi."
_paket_silinsinmi="paketi kaldırılsın mı?"
_paket_tanimsiz="paketi tanımsız!"
_paket_bulunamadi="ilgili paket bulunamadı!"
_paketvt_guncelleniyor="paket veritabanı güncelleniyor."
_paket_onbellek_depoda_var="paketi önbellek depoda bulunmakta."
_paket_depoda_yok="paket depoda bulunmuyor ve gereksiz,"
_siliniyor="siliniyor"
_git_guncelleniyor="git sunucudan güncelleme çekiliyor."
_git_guncel="git deposu güncel"
_git_guncellendi="git deposu güncellendi."
_yerel_esitlendi="yerele eşitleme tamam."
_yerel_esitlendi_olumsuz="yerele eşitleme olumsuz."
_yerel_esitleniyor="yerele eşitleniyor."
_devir_kontrol_iptal="devir kontrolü iptal edildi!"
_surum_kontrol_iptal="sürüm kontrolü iptal edildi!"
_zaten="zaten"
_indiriliyor="indiriliyor"

export _paketguncel=0

hata_olustu(){
	local _hata _mesaj
	[ -z $1 ] && exit 1
	_hata=$1
	case $_hata in
	"_paket_adi_gerekli")
		_mesaj="$_paket_adi_gerekli"
		;;
	"_talimatsiz_dizin")
		_mesaj="$_talimatsiz_dizin"	
		;;
	"_talimat_bulunamadi")
		_mesaj="$_talimat_bulunamadi"	
		;;
	"_yerel_paket_yok")
		_mesaj="$_yerel_paket_yok"	
		;;
	*)
		_mesaj="böyle bir hata yok"
		;;
	esac
	echo ${_mesaj}
	exit 1
}

cikti_renk_ayarla(){
	local cikti
	cikti="--renkli"
	if [ "$1" ]; then
		if [ "$1" = "--normal" ];then
			cikti="--normal"
		fi
	fi

	if [ $cikti = "--renkli" ];then
		_yaz="ryaz 32"
		_yaz_tm="ryaz 34"
		_yaz_uyari="ryaz 31"
	else
		_yaz="echo"
		_yaz_tm="echo"
		_yaz_uyari="echo"
	fi
}

icerik_ekle(){
	if [ -f "$1" ];then
		local cikti _yaz _yaz_tm _yaz_uyari
		if [ "$2" ]; then
			cikti="$2"
		fi
		#echo "cikti: $cikti"
		if [ "$cikti" == "--renkli" ];then
			_yaz="ryaz 32"
			_yaz_tm="ryaz 34"
			_yaz_uyari="ryaz 31"
		else
			cikti="--normal"
			_yaz="echo"
			_yaz_tm="echo"
			_yaz_uyari="echo"
		fi
		paketad=`echo "$1" | cut -d'#' -f1`	
		paketad=`basename $paketad`
		$_yaz_tm "$paketad paketi kuruluyor-> $kokdizin" 
		if [ -f /usr/bin/bsdtar ];then
			bsdtar -C /tmp --extract --file=$1 .PRE 1 2> /tmp/$paketad_pre.log
		else
			tar -C /tmp --extract --file=$1 .PRE 1 2> /tmp/$paketad_pre.log
		fi
		#kos-kur kontrolu
		if [ -f /tmp/.PRE ];then
			if [ "$kokdizin" == "/" ];then
				bash  /tmp/.PRE
			else
				cp /tmp/.PRE $kokdizin/tmp/$paketad.PRE
			fi
			rm  /tmp/.PRE
		fi
		mkdir -p kur.$paketad &&
		if [ -f /usr/bin/bsdtar ];then
			bsdtar xf $1 -C kur.$paketad
		else
			tar xf $1 -C kur.$paketad
		fi
		#istenmeyen yerellerin silinmesi
		if [ -d kur.$paketad/usr/share/locale ] && [ "$yerelsil" == "evet" ];then
			for lkl in `ls kur.$paketad/usr/share/locale/`;do
				if [ "$lkl" != "$lokal" ];then rm -r kur.$paketad/usr/share/locale/$lkl; fi
			done
		fi
		#doc dizini silinmesi
		if [ -d kur.$paketad/usr/share/doc ] && [ "$docsil" == "evet" ];then
			rm -r kur.$paketad/usr/share/doc
		fi
		mkdir -p $kokdizin$VT/"$paketad" && 
		cp -v -afr kur.$paketad/* $kokdizin > kur.$paketad/kurulan 
		cp kur.$paketad/kurulan /tmp/ &&cat kur.$paketad/kurulan | cut -d '>' -f2 > $kokdizin$VT/"$paketad"/kurulan &&
		#mv  kur.$paketad/.MTREE $VT/"$paketad"/files &&
		mv  kur.$paketad/.META $kokdizin$VT/"$paketad"/META &&
		
		#kur-kos calistirilmasi
		if [ -f kur.$paketad/.POST ];then
			if [ "$kokdizin" == "/" ];then
				bash  kur.$paketad/.POST
			else
				cp kur.$paketad/.POST $kokdizin/tmp/$paketad.POST
			fi
			rm  kur.$paketad/.POST
		fi
		
		rm -r kur.$paketad
		if [ -f $kokdizin/etc/ld.so.conf ];then
			ldconfig -r $kokdizin
		fi
		$_yaz_tm "$paketad $_paket_kuruldu"
		loglama "$paketad $_paket_kuruldu"
	else
		$_yaz_uyari "icerik_ekle:paket konum parametresi boş!!!"
		exit 1
	fi
	
}

paket_sil(){
	local paket kkont sil_onay oto_silme cikti _yaz _yaz_uyari _yaz_tm
	paket="$1"
	tersbag_goster="hayir"
	
	cikti="--renkli"
	if [ "$2" ]; then
		if [ "$2" == "--normal" ];then
			cikti="--normal"
		else
			oto_silme="$2"
		fi
	fi
	
	if [ "$3" ]; then
		if [ "$3" == "--normal" ];then
			cikti="--normal"
		else
			tersbag_goster="evet"
		fi
	fi
	
	if [ $cikti == "--renkli" ];then
		_yaz="ryaz 32"
		_yaz_tm="ryaz 34"
		_yaz_uyari="ryaz 31"
	else
		_yaz="echo"
		_yaz_tm="echo"
		_yaz_uyari="echo"
	fi
	
	if [ "$tpk" = "evet" ] && [ -d "$talimatname/temel/$1" ];then
		$_yaz_uyari "$1 temel sistem paketidir.Silinemez!!!"
		hataloglama "$1 temel sistem paketidir.Silinemez!!!"
	else
		kkont=`kurulu_kontrol "$1"`
		if [ "$kkont" = "kurulu" ];then
			if [ -f "$VT/$paket/kurulan" ];then
                #dizin koruma
                etkilenen_kurtar $1 $cikti
				cat $VT/$paket/kurulan | cut -d '>' -f2 > /tmp/$paket.sil
				if [ "$tersbag_goster" = "evet" ];then
					$_yaz_uyari "ters bagimliliklar"
					$_yaz_uyari "------------------"
					ters_bagimli_bilgi "$paket"
					$_yaz_uyari "------------------"
				fi
				
				$_yaz_uyari "etkilenen dosyalar"
				$_yaz_uyari "------------------"
				silme_etkilenen_kontrol /tmp/$paket.sil $paket
				$_yaz_uyari "------------------"
				#fi
				if [ "$oto_silme" = "evet" ];then
					sil_onay="e"
				else
					while true; do
						$_yaz_tm $paket" $_paket_silinsinmi";read -p "e veya h-> " eh
						case $eh in
							[Ee]* ) sil_onay="e"; break;;
							[Hh]* ) break;;
							* ) echo "e veya h";;
						esac
					done
				fi
				if [ "$sil_onay" = "e" ];then
					_konum=$(talimat_bul $paket)									
					[ -f "$_konum/$paket.kos-sil" ] && bash "$_konum/$paket.kos-sil"
					xargs rm -r -f < /tmp/$paket.sil &&
					rm -r -f "$VT/$paket" &&
					[ -f "$_konum/$paket.sil-kos" ] && bash "$_konum/$paket.sil-kos"
					$_yaz_tm $paket" $_paket_silindi"
					loglama "$paket $_paket_silindi"
					rm -f /tmp/$paket.sil
				else
					rm -f /tmp/$paket.sil
				fi
				
			else
				$_yaz_uyari "kritik mesaj:kurulanlar dosyası yok." 
				hataloglama "kritik mesaj:kurulanlar dosyası yok." 
			fi
		elif [ "$kkont" = "degil" ];then
			$_yaz "$_zaten $paket $_paket_kurulu_degil"
			hataloglama "$_zaten $paket $_paket_kurulu_degil"
		else
			$_yaz "$_paket_tanimsiz"
			hataloglama "$_paket_tanimsiz"
		fi
	fi

}

paket_ara(){
	paket="$1"
	for pkt in `cat /depo/paketler/paket*.vt  | grep $paket |  awk '{print $1}'`; do
		pakdesc=$(find $talimatname -name "$pkt" | xargs -I %  sed -n '1{p;q}' %/talimat | sed s'/# Tanım: //g');
		ryaz 34 "$pkt - $pakdesc";
	done
}

paket_liste(){
	mps_paketler_listesi="/tmp/mps_paketler_listesi"
	local cikti _grup
	_grup="yok"
	cikti="--normal"
	if [ "$1" ]; then
		if [ "$1" == "--json" ];then
			cikti="--json"
		else
			_grup="$1"
		fi
	fi
	if [ "$2" ]; then
		cikti="$2"
	fi
	#echo "cikti:$cikti"
	#echo "grup:$_grup"
	#exit 1
	if [ $_grup == "yok" ];then
		if [ $cikti == "--json" ];then
			[ -f $mps_paketler_listesi ] && rm -rf $mps_paketler_listesi
			for pkt in $(cat /depo/paketler/paket*.vt  | awk '{print $1}'); do
				printf "$pkt," >> $mps_paketler_listesi
			done
			sed -i s'/.$//' $mps_paketler_listesi
		else
			cat /depo/paketler/paket*.vt  | awk '{print $1}'
		fi
	else
		if [ $cikti == "--json" ];then
			grup_paketler_liste $_grup $cikti
		else
			grup_paketler_liste $_grup
		fi
	fi
}

paket_grup_liste(){
	mps_paket_grup_listesi="/tmp/mps_paket_grup_listesi"
	local cikti
	cikti="normal"
	if [ "$1" ]; then
		cikti="$1"
	fi
	_gruplar=`grep -ri "Grup:" $talimatname/* $ektalimatname/* | cut -d':' -f3 | cut -d' ' -f2 | sed 's/^ *//;s/ *$//' | sort -u`
	if [ $cikti == "--json" ];then
		[ -f $mps_paket_grup_listesi ] && rm -rf $mps_paket_grup_listesi
		#printf "[" >> $mps_paket_grup_listesi
		for grp in $(grep -ri "Grup:" $talimatname/* $ektalimatname/* | cut -d':' -f3 | cut -d' ' -f2 | sed 's/^ *//;s/ *$//' | sort -u); do
			printf "$grp," >> $mps_paket_grup_listesi
		done
		sed -i s'/.$//' $mps_paket_grup_listesi
		#printf "]" >> $mps_paket_grup_listesi
	else
		echo $_gruplar
	fi
}

grup_paketler_liste(){
	mps_grup_paketler_listesi="/tmp/mps_grup_paketler_listesi"
	local cikti _grup _paketler
	_grup="$1"
	cikti="normal"
	if [ "$2" ]; then
		cikti="$2"
	fi
	_paketler=`grep -rli "Grup: .*$_grup" $talimatname/* $ektalimatname/* | cut -d':' -f3 | sed 's/^ *//;s/ *$//' | xargs -I {}  dirname {} | xargs -I {}  basename {} | sort -u`
	if [ $cikti == "--json" ];then
		[ -f $mps_grup_paketler_listesi ] && rm -rf $mps_grup_paketler_listesi
		#printf "[" >> $mps_paket_grup_listesi
		for pkt in $(grep -rli "Grup: .*$_grup" $talimatname/* $ektalimatname/* | cut -d':' -f3 | sed 's/^ *//;s/ *$//' | xargs -I {}  dirname {} | xargs -I {}  basename {} | sort -u); do
			printf "$pkt," >> $mps_grup_paketler_listesi
		done
		sed -i s'/.$//' $mps_grup_paketler_listesi
		#printf "]" >> $mps_paket_grup_listesi
	else
		echo $_paketler
	fi
}

kelime_bul(){
	grep --color -H -ri "$1" $talimatname
	grep --color -H -ri "$1" $ektalimatname
}

kurulu_kontrol_test(){
	local _paket kkont cikti _yaz _yaz_uyari
	_paket=$1
	cikti="--renkli"
	_yaz_son=""
	if [ "$2" ]; then
		cikti="$2"
	fi
	if [ $cikti == "--normal" ];then
		_yaz="echo"
		_yaz_uyari="echo"
	elif [ $cikti == "--renkli" ];then
		_yaz="ryaz 32"
		_yaz_uyari="ryaz 31"
	fi
	kkont=`kurulu_kontrol "$1"`
	if [ "$kkont" == "degil" ];then
		$_yaz_uyari "$_paket $_paket_kurulu_degil"
		exit 1
	elif [ "$kkont" == "tanimsiz" ];then
		$_yaz_uyari "$_paket $_paket_tanimsiz"
		exit 1
	fi
}

paket_bilgi(){
	local _paket kkont cikti _yaz _yaz_uyari _yaz_son
	_paket="$1"
	cikti="--renkli"
	_yaz_son=""
	if [ "$2" ]; then
		cikti="$2"
	fi
	if [ $cikti == "--html" ];then
		_yaz="echo"
		_yaz_uyari="echo"
		_yaz_son="<br>"
	elif [ $cikti == "--renkli" ];then
		_yaz="ryaz 32"
		_yaz_uyari="ryaz 31"
	else
		#echo "tanımsız çıktı seçeneği,normal çıktı verilecek."
		_yaz="echo"
		_yaz_uyari="echo"
		_yaz_son="<br>"
	fi
	
	kkont=`kurulu_kontrol "$1"`

	if [ "$kkont" = "kurulu" ];then
		satir=`sed -n '1p' <  $VT/"${_paket}"/META`
		$_yaz "ADI        :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '2p' <  $VT/"${_paket}"/META`
		$_yaz "TANIM      :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '3p' <  $VT/"${_paket}"/META`
		$_yaz "URL        :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '5p' <  $VT/"${_paket}"/META`
		$_yaz "PAKETÇİ    :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '6p' <  $VT/"${_paket}"/META`
		satir=${satir:1:${#satir}-1} 
		printf -v boyut '%d\n' "$satir" 2>/dev/null
		if [ $boyut -lt 1048576 ];then
			boyut=$(($boyut/1024))
			_ek="kb"
		else
			boyut=$(($boyut/1024/1024))
			_ek="mb"
		fi
		$_yaz "KUR BOYUT  :" "$boyut $_ek (tahmini)" #$_yaz_son
		satir=`sed -n '7p' <  $VT/"${_paket}"/META`
		$_yaz "SÜRÜM      :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '8p' <  $VT/"${_paket}"/META`
		$_yaz "DEVİR      :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '9p' <  $VT/"${_paket}"/META`
		$_yaz "PAKETLENME :" `date -d @${satir:1:${#satir}-1}` #$_yaz_son
		satir=`sed -n '10p' <  $VT/"${_paket}"/META`
		$_yaz "MİMARİ     :" ${satir:1:${#satir}-1} #$_yaz_son
		satir=`sed -n '11p' <  $VT/"${_paket}"/META`
		$_yaz "GRUP       :" ${satir:1:${#satir}-1} #$_yaz_son
	elif [ "$kkont" = "degil" ];then
		_konum=$(talimat_bul $1)
		source ${_konum}/talimat
		_ad=$(basename ${_konum})
		_tanim=$(grep -ri "# Tanım:" $_konum/talimat | cut -d ':' -f2-)
		_url=$(grep -ri "# Url:" $_konum/talimat | cut -d ':' -f2-)
		_paketci=$(grep -ri "# Paketçi:" $_konum/talimat | cut -d ':' -f2-)
		_surum=${surum}
		_devir=${devir}
		_grup=$(grep -ri "# Grup:" $_konum/talimat | head -1 | cut -d ':' -f2)
		$_yaz "ADI        :" ${_ad} #$_yaz_son
		$_yaz "TANIM      :" ${_tanim} #$_yaz_son
		$_yaz "URL        :" ${_url} #$_yaz_son
		$_yaz "PAKETÇİ    :" ${_paketci} #$_yaz_son
		$_yaz "SÜRÜM      :" ${_surum} #$_yaz_son
		$_yaz "DEVİR      :" ${_devir} #$_yaz_son
		$_yaz "GRUP       :" ${_grup} #$_yaz_son
		$_yaz_uyari "${_paket} $_paket_kurulu_degil"
	else
		$_yaz_uyari "${_paket} $_paket_tanimsiz"
	fi
}

paket_bilgi_html(){
	_simgedepo="/srv/http/mpsweb/static/simgeler"
	_simgehtmldepo="/static/simgeler"
	_simgedosya=""
	_dosya=$1
	_paket=`echo "${_dosya}" | cut -d'_' -f4-5`
	icerik="<table border=1>"
	# ikon arşive baktırılacak varsa programın kendi ikonu yoksa öntanımlı ikon kullanılacak
	
	if [ -f $_simgedepo/${_paket}.png ];then 
		_simgedosya="$_simgehtmldepo/$_paket.png"
	elif [ -f /usr/share/icons/hicolor/32x32/apps/${_paket}.png ];then 
		cp /usr/share/icons/hicolor/32x32/apps/${_paket}.png $_simgedepo/${_paket}.png
		_simgedosya="$_simgehtmldepo/$_paket.png"
	elif [ `ls $_simgedepo/${_paket}_* 2>/dev/null | head -n1` ];then
		_gecicidosya=`ls $_simgedepo/${_paket}_* 2>/dev/null | head -n1`
		_simgedosya="$_simgehtmldepo/$(ls $_gecicidosya | xargs -I {}  basename {})"
	else
		_simgedosya="$_simgehtmldepo/package.png"
	fi

	icerik+="<tr><td align=center><img src='${_simgedosya}' alt='' weight=40 height=40></img><td></tr>"
	while IFS='' read -r satir || [[ -n "$line" ]]; do
		icerik+="<tr>"
		_sutun_baslik="$(echo $satir | cut -d':' -f1)"
		_sutun_deger="$(echo $satir | cut -d':' -f2-)"
		
		#icerik+="<td>$_sutun_deger</td>"
		if [ "${_sutun_baslik}" != "${_sutun_deger}" ];then 
			icerik+="<td>$_sutun_baslik</td>"
			icerik+="<td>$_sutun_deger</td>"
		fi
		icerik+="</tr>"
	done < "$_dosya"
	
	if [[ "${_sutun_baslik}" == *"${_paket_kurulu_degil}"* ]] || [[ "${_sutun_baslik}" == *"${_paket_tanimsiz}"* ]];then 
		icerik+="<tr bgcolor='red'><td>DURUM</td><td>${_sutun_baslik}</td></tr>"
	else
		icerik+="<tr bgcolor='green'><td>DURUM</td><td>kurulu</td></tr>"
	fi
	icerik+="</table>"
	echo "$icerik" > $_dosya.html
}

# paketlerin toplu tablo gösterimi
paketler_depo_html(){
	icerik="<table border=1>"
	for _paket in $(ls $VT);do
		# ikon arşive baktırılacak varsa programın kendi ikonu yoksa öntanımlı ikon kullanılacak
		_simgedosya="/static/package.png"
		#echo "dosya: $_simgedepo/${_paket}.png"
		[ -f $_simgedepo/${_paket}.png ] && _simgedosya="$_simgehtmldepo/$_paket.png"
		[ $(ls $_simgedepo/${_paket}_* | head -n1) ] && _simgedosya="$_simgehtmldepo/$(ls $_simgedepo/${_paket}_* | head -n1 | xargs -I {}  basename {})"
		icerik+="<tr><td align=center><img src='${_simgedosya}' alt='' weight=40 height=40></img><td><td>$_paket</td></tr>"
	done
	icerik+="</table>"
	echo "$icerik" > /tmp/test.html
}

yeniden_paketle(){
		cd $1
		bsdtar -r -f  ../"$1".mps .META
		bsdtar -r -f  ../"$1".mps *
		cd ..
		lzip -9 "$1".mps
}

talimat_bul(){
	local _apaket _bulunan _sonuc _donus _konum
	[ -z $1 ] && hata_olustu "_paket_adi_gerekli"
	_konum="$talimatname $ektalimatname"
	[ ! -z $2 ] && _konum="$2"
	_donus="-1"
	_apaket="$1"
	_sonuc=$(find $_konum -name ${_apaket} | wc -l)
	if [ ${_sonuc} -eq 0 ];then echo $_donus;return; fi
	_bulunan=$(find $_konum -name ${_apaket} | head -n1)
	#if [ ! -f "${_bulunan}/talimat" ];then hata_olustu "_talimatsiz_dizin";return; fi
	if [ ! -f "${_bulunan}/talimat" ];then echo ${_donus};return; fi
	[ ${_sonuc} -gt 1 ] && echo "$(date +'%F %T') ${_apaket} $_talimat_sayisi_fazla" >> $LOGDIZIN/mps-hata.log
	echo ${_bulunan}
}

paket_analiz(){
	_gcc_uyumsuz_paketler="/tmp/gcc_uyumsuz_paketler"
	_pkvt="paket.vt"
	if [ -z "$1" ];then echo "$_paket_adi_gerekli";exit 1;fi
	local pkt _apaket _konum
	pkt=$1
	if [ -f $pkt ];then
		_apaket=$(basename $pkt |cut -d'#' -f 1)
		_konum=$(talimat_bul $_apaket $anatalimatname)
		_depo_sha=$(cat "$paketdepo$_pkvt"  | grep " $_apaket#" | cut -d' ' -f2)
		_paket_sha=$(sha1sum $pkt | cut -d ' ' -f1)
		if [[ $_konum != "-1" && $_konum != "0" ]];then
			source $_konum/talimat
			if [ -f $pkt ];then
				bsdtar xf $pkt .META 
				if [ -f $PWD/.META ];then
					mv .META  /tmp/$_apaket.META
					satir=$(sed -n '7p' <  /tmp/$_apaket.META)
					psurum=${satir:1:${#satir}-1}
					satir2=$(sed -n '8p' <  /tmp/$_apaket.META)
					pdevir=${satir2:1:${#satir2}-1}
					deposurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
					depodevir=`echo -e "$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
					_surumbilgi="gereken_sürüm:$deposurum ! paket_sürüm:$psurum"
					_devirbilgi="gereken_devir:$depodevir ! paket_devir:$pdevir"
					ryaz 33 "$pkt"
					if [ "$deposurum" != "$psurum" ];then
						ryaz 31 "$_surumbilgi"
						echo "$pkt" >> $_gcc_uyumsuz_paketler
					fi
					if [ "$depodevir" != "$pdevir" ];then
						ryaz 31 "$_devirbilgi"
						echo "$pkt" >> $_gcc_uyumsuz_paketler
					fi
					if [ "$_paket_sha" != "$_depo_sha" ];then
						ryaz 31 "$_shasum_uyumsuzluk"
						echo "$pkt" >> $_gcc_uyumsuz_paketler
					fi
				else
					ryaz 31 "$_apaket depoda yok. mps -i $_apaket"
				fi
			else
				ryaz 31 "$_apaket depoda yok. mps -i $_apaket"
			fi
		else
			ryaz 31 "$1 $_talimat_bulunamadi"
		fi
		rm -f /tmp/$_apaket.META
	else
		ryaz 31 "$pkt $_dosya_yolu_bulunamadi"
		exit 0
	fi
}	

paketdepo_analiz(){
	paketvt_guncelle
	_aranandepo=$1
	_uyumsuz_paketler="/tmp/uyumsuz_paketler"
	if [[ -d $_aranandepo && ! -f $_aranandepo ]];then
		rm -f $_uyumsuz_paketler
		_gcc_uyumsuz_paketler="/tmp/gcc_uyumsuz_paketler"
		for pkt in $(ls $_aranandepo*mps.lz);do
			paket_analiz $pkt
			echo "-"
		done
		echo "tarama bitti"
		sort -u $_gcc_uyumsuz_paketler > $_uyumsuz_paketler
		echo "file://$_uyumsuz_paketler"
		exit 0
	else
		ryaz 31 "$1 $_dizin_bulunamadi"
		exit 1
	fi
}

derleme_listyap_kontrol(){
	
	if [ -f gerek.liste ];then
		mv gerek.liste gerek.eski.liste
	fi
	if [ -f gerek.konum.liste ];then
		mv gerek.konum.liste gerek.konum.eski.liste
	fi
	touch gerek.liste 
	touch gerek.konum.liste 
}

gerekleri_dosyala(){
	local _altgerek _konum
	_altgerek="$1"
	_konum=$(talimat_bul $_altgerek)
	if [[ $konum != "-1" && $konum != "0" ]];then
		printf "."
		echo "$_altgerek" >> gerek.liste 
		if [ ! -d "$talimatname/temel/$_altgerek" ];then
			echo "$_konum" >> gerek.konum.liste 
		fi
	else
		ryaz 31 "$1 $_talimat_bulunamadi"
	fi
}

gerekleri_listele(){
	derleme_listyap_kontrol
	local _paket _konum _pkvt
	_konum="$talimatname $ektalimatname"
	[ $1 ] && _paket=$1 || hata_olustu "_talimat_bulunamadi"	
	_pkvt=""
	[ "$2" = "--kurulu_atla" ] && _pkvt="$VT"
	#echo "arama konum: $_konum"
	echo $_paket | awk -v arama_konum="$_konum" -v PKVT="$_pkvt" \
	'''
	function gerekbul(paket,gerekler) { 
		if (ISLENDI[paket]) {
			return
		}
		while((getline satir<paket) >0) {  
			if (satir ~ "# Gerekler:" ){         
				split(satir,gerekb,":");
				split(gerekb[2], gerekler, /[ ,]+/);
				if ( length(gerekler) > 0 ){
					for (i in gerekler){
						if ( i > 1 && length(gerekler[i]) > 0 ){
							ara=gerekler[i]
							konum=talimat_bul(ara);
							
							if (konum != ""){
								if (length(PKVT) > 0 ){ 
									(kk(PKVT "/" ara))? yaz("."):gerekbul(konum)
								}
								else {gerekbul(konum)}
							}
						}
					}
				}
			}
		}
		ISLENDI[paket]=1 ; 
		printf "."
		system("echo $(dirname " paket ") >> gerek.konum.liste")
		system("echo $(basename $(dirname " paket ")) >> gerek.liste")
		close(paket)	
	}
	# kurulu kontrol
	function kk(p) {
	  return !system("test -d \""p"\"");
	}
	
	function yaz(_param){
		printf _param
	}
	
	function talimat_bul(ara){
		cmd= "find " arama_konum " -name " ara " | head -n1 "
		_bulundu=0
		while ( ( cmd | getline talimatyol ) > 0 ) {
			_bulundu=1
			break
		} 
		close(cmd)
		if ( _bulundu == 0 ) {
			print ara " talimatı bulunamadı";
			exit 1
		}
		return talimatyol "/talimat"
	}


	{
		#print FILENAME
		_talimat=$1
		_paket=talimat_bul(_talimat)
		if ( length(_paket) > 0 ){gerekbul(_paket);}
		else {print _talimat " talimatı bulunumadı!"}
		exit 1
	}
	'''
	[ -f gerek.liste ] && cat gerek.liste | tr "\n" " ";echo
}


dly_yeni(){
	local _paket="$1"
	dlymap+=";${_paket};"
	altgerekler="$(bagimlilar $_paket)"
	if [[ "$altgerekler" != "0" && "$altgerekler" != "-1" ]];then
		for altgerek in ${altgerekler};do
			if [[ "$dlymap" != *";${altgerek};"* ]]; then
				dly_yeni $altgerek
			fi
		done
		dlyD+="$_paket "
		gerekleri_dosyala "$_paket"	
	else
		ryaz 31 "$_paket talimatı bulunamadı."
		exit 1 
	fi
}

kly_yeni(){
	local _paket="$1"
	[ ! -d "$VT/$1" ] && klymap+=";${_paket};"
	altgerekler="$(bagimlilar $_paket)"
	if [[ "$altgerekler" != "0" && "$altgerekler" != "-1" ]];then
		for altgerek in ${altgerekler};do
			if [ ! -d "$VT/$altgerek" ] ;then
				if [[ "$klymap" != *";${altgerek};"* ]]; then
					kly_yeni $altgerek
				fi
			fi
		done
		klyD+="$_paket "
		gerekleri_dosyala "$_paket"	
	else
		ryaz 31 "$_paket talimatı bulunamadı."
		exit 1 
	fi
}

derleme_listyap_eski(){
	ryaz 32 "$1 $_gerekler_belirleniyor"
	dlyD=""
	dlymap=""
	derleme_listyap_kontrol
	dly_yeni $1
	echo "${dlyD}"
}

derleme_listyap(){
	ryaz 32 "$1 $_gerekler_belirleniyor"
	gerekleri_listele $@
}

derleme_listbilgi(){
	ryaz 34 "yapim asamasında"
}

# -derlist
paket_derle_liste(){
	for dpktyer in `cat $1`;do
		dpkt=`basename $dpktyer`
		echo $dpkt "derleniyor...."
		zorla_derle="yok"
		paket_derle $dpktyer
	done
}

#otomatik derle kontrollu kur
# -derle
paket_derle_kur(){
	tekrarkur="hayir"
	derleme_listyap_kontrol
	derleme_listyap "$1"  && paket_derle_liste gerek.konum.liste
}

# odkp
oto_derle_kur_paketle(){
	paketvt_guncelle
	# mps -kur
	_konum=$(talimat_bul $1)
	paket_inkur_oto $1 &&
	if [ -f  "$_konum/$1.sira" ];then
		ryaz 32 "sıralı derleme yapılacak."
		paket_derle_liste "$_konum/$1.sira"
	else
		paket_derle_kur $1
	fi 
	rm -rf {gerek.konum.eski,gerek.konum,gerek,kurulanlar,silinenler,gerek.eski}.liste
}

paket_kur_oto(){
	local kpkt pkt pak kliste
	if [ "$1" = "-H" ];then
		ls *.mps.lz > "otokur.list"
		kliste="otokur.list"
	else
		kliste="$1"
	fi
	for kpkt in `cat $kliste`;do
		for pkt in `ls $kpkt* | cut -d'#' -f1`;do
			pak=`ls "$pkt#"*`
			yerelden_kur "$pak" && paket_inkur_oto "$pkt"
		done
	done
	rm -rf otokur.list
}

paket_kur_oto_zorla(){
	local kpkt pkt pak kliste
	if [ "$1" = "-H" ];then
		ls *.mps.lz > "otokur.list"
		kliste="otokur.list"
	else
		kliste="$1"
	fi
	for kpkt in `cat $kliste`;do
		for pkt in `ls $kpkt* | cut -d'#' -f1`;do
			pak=`ls "$pkt#"*`
			paket_sil "$pkt" "evet"
			yerelden_kur "$pak" && paket_inkur_oto "$pkt"
		done
	done
	rm -rf otokur.list
}

paket_kur_liste(){
	local kpkt pkt pak
	for kpkt in `cat $1`;do
		for pkt in `ls $kpkt* | cut -d'#' -f1`;do
			pak=`ls "$pkt#"*`
			yerelden_kur "$pak"
		done
	done
}

paket_kur_liste_zorla(){
	local kpkt pkt pak
	for kpkt in `cat $1`;do
		for pkt in `ls $kpkt* | cut -d'#' -f1`;do
			pak=`ls "$pkt#"*`
			paket_sil "$kpkt" "evet"
			yerelden_kur "$pak"
		done
	done
}

#otomatik kontrollu kur
paket_kur_oto2(){
	derleme_listyap_kontrol
	derleme_listyap "$1" > /dev/null && mps -ok gerek.konum.liste
}

paket_inkur_liste_direk(){
	local kpkt
	for kpkt in `cat $1`;do
		agdan_kur "$kpkt"
	done
}

paket_inkur_liste(){
	local kpkt
	for kpkt in `cat $1`;do
		paket_inkur_oto "$kpkt"
	done
}

# otomatik kontrollu kur
# -kur
paket_inkur_oto(){
	local _cikti _yaz _yaz_uyari _pkt
	_cikti="--renkli"
	[ $1 ] && _pkt="$1" || hata_olustu "_paket_adi_gerekli"
	[ $2 ] && _cikti="$2"
	cikti_renk_ayarla $_cikti
	
	local konum anakonum kurdurum _agdan_kur_onay
	derleme_listyap_kontrol
	derleme_listyap ${_pkt} "--kurulu_atla"
	
	for kpkt in `cat gerek.liste`;do	
		# önce talimat-anatalimat karşılaştırması yapılır.
		konum="`find "$talimatname" -name $kpkt`"
		anakonum="`find "$anatalimatname" -name $kpkt`"
		ekkonum="`find "$ektalimatname" -name $kpkt`"
		if [ -f  "$anakonum/talimat" ];then
			# depo ve talimatname sürüm kontrolü
			_gncdurum=""
			[ "$(kurulu_kontrol ${kpkt})" = "kurulu" ] && _gncdurum=$(surum_karsilastir ${kpkt})
			_agdan_kur_onay="x"
			if [ "${_gncdurum}" == "degil" ];then
				_agdan_kur_onay="h"
			elif [ "`dosya_karsilastir $konum/talimat $anakonum/talimat`" = "evet" ];then
				_agdan_kur_onay="e"	
			else
				_agdan_kur_onay="h"
				$_yaz_uyari "$kpkt talimat eşitsizliğinden atlandı." 
			fi
			[ $_agdan_kur_onay == "x" ] && exit 1
			[ $_agdan_kur_onay == "e" ] && agdan_kur "$kpkt" "$_cikti"
		# ek talimatlar için sürüm karşılaştırma henüz yok.farklı depolara bakılarak sağlanacak
		elif [ -f  "$ekkonum/talimat" ];then
			agdan_kur "$kpkt" "$_cikti"
		else
			$_yaz_uyari "$kpkt talimatı bulunamadı!"
		fi
	done
	if [ $(kurulu_kontrol ${_pkt}) = "degil" ];then
		kurdurum="kurulu değil"
	elif [ $(kurulu_kontrol ${_pkt}) = "kurulu" ];then
		kurdurum="kurulu"
		#_gnc_kntrl=$(surum_devir_kontrol "${_pkt}" "--normal")
		#if [ ${_gnc_kntrl} = "var" ];then
		#	paket_guncelle ${_pkt}
		#else
			$_yaz "${_pkt} $kurdurum"
		#fi
	else
		kurdurum="$_paket_tanimsiz"
	fi
	rm -rf *.liste
}

paket_sil_oto(){
	local spkt
	for spkt in `cat $1`;do
		oto_silme="evet"
		paket_sil "$spkt" "$oto_silme"
	done
}

paket_sil_oto_onayli(){
	local spkt
	#for spkt in `perl -e 'print reverse <>' $1`;do
	for spkt in $(tac $1);do
		paket_sil "$spkt" "hayir" "evet"
	done
}

paket_sil_gereklerle(){
	local _onay _tbs _tbsnc _paket _ustgerek
	[ $1 ] && _paket="$1" || hata_olustu "_paket_adi_gerekli"
	if [ -d $VT/${_paket} ];then
		bagimli_bilgi_dosyala "${_paket}"
		rm -f /tmp/${_paket}.silinecekler
		touch /tmp/${_paket}.silinecekler
		_tbsnc=$(ters_bagimli_bilgi ${_paket} "kurulu")
		if [ -z "${_tbsnc}" ];then _tbs=0 
		else _tbs=$(echo "$_tbsnc" | wc -l)
		fi
		if [ $_tbs -gt 0 ];then
			ryaz 31 "${_paket} silinemez."
			echo "ters gerekleri:";echo "$_tbsnc"
			exit 1
		fi
		for pkaltb in $(cat /tmp/${_paket}.gerekler.liste);do
			if [ -d $VT/$pkaltb ];then
				_tbsnc=""
				_tbsnc=$(ters_bagimli_bilgi $pkaltb "kurulu")
				if [ -z "${_tbsnc}" ];then _tbs=0 
				else _tbs=$(echo "$_tbsnc" | wc -l)
				fi
				echo "$pkaltb >"
				if [ -f ${pkaltb}.tbk.txt ];then
					_ustgerek=$(cat /tmp/${_paket}.silinecekler | grep -f ${pkaltb}.tbk.txt)
					[ ${_ustgerek} ] &&  _tbs=0
				fi
				if [ $_tbs -eq 0 ];then
					ryaz 32 "$pkaltb silinebilir."
					echo "$pkaltb" >> /tmp/${_paket}.silinecekler
				elif [ "$_tbsnc" = "${_paket}" ];then
					ryaz 32 "$pkaltb silinebilir."
					echo "$pkaltb" >> /tmp/${_paket}.silinecekler
				else
					ryaz 31 "$pkaltb silinemez."
					echo "ters gerekleri: $tbsonuc"
				fi
			else
				ryaz 32 "$_zaten $pkaltb $_paket_kurulu_degil"
			fi
		done
		_onay="onay"
		# otomatik onay verme durum kontrolü
		if [ ! -z "$2" ];then _onay="$2";fi
		#cat /tmp/${_paket}.silinecekler
		if [ $_onay = "oto" ];then
			paket_sil_oto "/tmp/${_paket}.silinecekler"
		else
			paket_sil_oto_onayli "/tmp/${_paket}.silinecekler"
		fi
	else
		ryaz 32 "$_zaten ${_paket} $_paket_kurulu_degil"
		exit 1
	fi
}

paketsiz_talimatlar(){
	for talimatyol in `( ls -d $talimatname/genel/*/*  & ls -d $ektalimatname/*/*  ) | cat`;do
		#echo $talimat
		if [ -d $talimatyol ];then
			talimat=$(basename $talimatyol)
			if [[ ! $(cat $paketdepo/paket*.vt | grep  $talimat#) ]] ;then 
				if [ -d $talimatname/*/*/$talimat ];then
					ack=`grep -e '# Tanım:' $talimatname/genel/*/$talimat/talimat | cut -d':' -f2`
				elif [ -d $ektalimatname/*/$talimat ];then
					ack=`grep -e '# Tanım:' $ektalimatname/*/$talimat/talimat | cut -d':' -f2`
				fi
				printf '%s = %s \n' "$talimat" "$ack"
			fi
		fi
	done
}

paket_guncelle(){
	surum_kontrol $1 $2 $3
	if [ -d "$VT/$1" ];then
		if [ ${_paketguncel} -eq 0 ];then
			devir_kontrol $1 $2 $3
		else
			ryaz 32 "$1 paketi yeni güncellendi."
			ryaz 32 "devir güncellemesi yapılmayacak."
		fi
	fi
	export _paketguncel=0
}

paket_guncelle_oto(){
	derleme_listyap "$1" > /dev/null &&
	local kpkt
	GS_CIKTI="H"
	for kpkt in `cat gerek.konum.liste`;do
		durum=`kurulu_kontrol "$kpkt"`
		if [ "$durum" = "kurulu" ]; then
			paket_guncelle "$kpkt" $GS_CIKTI
		fi
	done
	listeleri_temizle
}

dongu_gosterge(){
	count=0
	total=$1
	pstr="[=======================================================================]"
	while [ $count -lt $total ]; do
	  sleep 0.5 # yapılacak iş veya uyutulur.
	  count=$(( $count + 1 ))
	  pd=$(( $count * 73 / $total ))
	  printf "\r%3d.%1d%% %.${pd}s" $(( $count * 100 / $total )) $(( ($count * 1000 / $total) % 10 )) $pstr
	done
}

guncelleme_tespit(){
	local _konum
	guncelleme_dosya="/tmp/mps.guncellenecekler"
	rm -f $guncelleme_dosya
	touch $guncelleme_dosya
	for kpaket in $(ls $VT/);do
		satir=$(sed -n '7p' <  $VT/$kpaket/META)
		ksurum=${satir:1:${#satir}-1}
		satir2=$(sed -n '8p' <  $VT/$kpaket/META)
		kdevir=${satir2:1:${#satir2}-1}
		#deposurum=$(grep " $kpaket#" /depo/paketler/paket.vt | cut -d' ' -f3 | cut -d'#' -f 2 | cut -d'-' -f1)
		_konum=$(talimat_bul $kpaket)
		if [ "$_konum" = "-1" ];then
			ryaz 31 "$kpaket $_talimat_bulunamadi $_surum_kontrol_iptal"
			#exit 1
		else
			source $_konum/talimat
			deposurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
			depodevir=`echo -e "$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
			#echo $kpaket "  :  $ksurum --->  $deposurum" "$kdevir --->  $depodevir"
			#sleep 3
			if [ "$ksurum" != "$deposurum" ];then
				printf "$kpaket -surum: ";echo "$ksurum --->  $deposurum"
				echo $kpaket >> $guncelleme_dosya
			elif [ "$kdevir" != "$depodevir" ];then
				printf "$kpaket -devir: ";echo "$kdevir --->  $depodevir"
				echo $kpaket >> $guncelleme_dosya
			fi
		fi
	done																																																									
}		

sistem_guncelle_eski(){
	count=0
	local kpkt _pkliste
	total=`ls $VT | wc -l`
	pstr="[=======================================================================]"
	git_guncelle
	paketvt_guncelle
	GS_CIKTI="H"
	_pkliste=$(mktemp)
	ls -rct $VT > ${_pkliste}
	for _esgec in `echo ${esgec} | tr " " "\n"`;do
		_satirno=$(grep -wxnr "${_esgec}" ${_pkliste} | cut -d':' -f1)
		[ ! -z ${_satirno} ] && sed  -i "${_satirno}d" ${_pkliste}
	done
	
	while [ $count -lt $total ]; do
		count=$(( $count + 1 ))
		pd=$(( $count * 73 / $total ))
		printf "\r%3d.%1d%% %.${pd}s" $(( $count * 100 / $total )) $(( ($count * 1000 / $total) % 10 )) $pstr
		kpkt=$(sed -n ${count}'p' ${_pkliste})
		[ ! -z $kpkt ] && paket_guncelle "$kpkt" $GS_CIKTI
	done
	ryaz 32 "\nSistem Güncellemesi Tamamlandı."
}

sistem_guncelle_uygula(){
	local _gdosya
	if [ "$1" ]; then
		_gdosya="$1"
	fi
	[ ! -f ${_gdosya} ] && exit 1
	for gpkt in `cat ${_gdosya}`;do
		durum=`kurulu_kontrol "$gpkt"`
		if [ "$durum" = "kurulu" ]; then
			paket_guncelle "$gpkt" $GS_CIKTI "E"
		fi
	done
}

sistem_guncelle(){
	local guncelleme_dosya _onay
	_onay=0
	if [ "$1" = "evet" ];then
		_onay=1
	fi
	if [ "$1" ] && [ -f "$1" ];then
		guncelleme_dosya="$1"
		[ "$2" = "evet" ] && _onay=1
	else
		count=0
		local kpaket _pkliste _konum
		guncelleme_dosya="/tmp/mps.guncellenecekler"
		rm -f $guncelleme_dosya
		touch $guncelleme_dosya
		total=`ls $VT | wc -l`
		pstr="[=======================================================================]"
		git_guncelle
		paketvt_guncelle
		GS_CIKTI="H"
		_pkliste=$(mktemp)
		ls -rct $VT > ${_pkliste}
		for _esgec in `echo ${esgec} | tr " " "\n"`;do
			_satirno=$(grep -wxnr "${_esgec}" ${_pkliste} | cut -d':' -f1)
			[ ! -z ${_satirno} ] && sed  -i "${_satirno}d" ${_pkliste}
		done
		
		while [ $count -lt $total ]; do
			count=$(( $count + 1 ))
			pd=$(( $count * 73 / $total ))
			printf "\r%3d.%1d%% %.${pd}s" $(( $count * 100 / $total )) $(( ($count * 1000 / $total) % 10 )) $pstr
			kpaket=$(sed -n ${count}'p' ${_pkliste})
			if [ ! -z $kpaket ];then
				satir=$(sed -n '7p' <  $VT/$kpaket/META)
				ksurum=${satir:1:${#satir}-1}
				satir2=$(sed -n '8p' <  $VT/$kpaket/META)
				kdevir=${satir2:1:${#satir2}-1}
				#deposurum=$(grep " $kpaket#" /depo/paketler/paket.vt | cut -d' ' -f3 | cut -d'#' -f 2 | cut -d'-' -f1)
				_konum=$(talimat_bul $kpaket)
				if [ "$_konum" = "-1" ];then
					ryaz 31 "$kpaket $_talimat_bulunamadi $_surum_kontrol_iptal"
					exit 1
				fi
				
				source $_konum/talimat
				deposurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
				depodevir=`echo -e "$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
				#echo $kpaket "  :  $ksurum --->  $deposurum" "$kdevir --->  $depodevir"
				#sleep 3
				if [ "$ksurum" != "$deposurum" ];then
					#printf "$kpaket -surum: ";echo "$ksurum --->  $deposurum"
					echo $kpaket >> $guncelleme_dosya
				elif [ "$kdevir" != "$depodevir" ];then
					#printf "$kpaket -devir: ";echo "$kdevir --->  $depodevir"
					echo $kpaket >> $guncelleme_dosya
				fi
			fi
		done
		ryaz 32 "\nSistem Güncelleme Taraması Tamamlandı."
		
	fi
	if [ -s "$guncelleme_dosya" ];then
		ryaz 33 "aşağıdaki paketler güncellenecektir:"
		cat $guncelleme_dosya
		ryaz 31 "Güncellemesini istemediğiniz paketleri $guncelleme_dosya dosyasından sildikten sonra onay veriniz!"
		if [ ${_onay} -eq 0 ];then
			while true; do
				ryaz 33 "listedeki paketler güncellensin mi?";read -p "e veya h-> " eh
				case $eh in
					[Ee]* ) sistem_guncelle_uygula $guncelleme_dosya; break;;
					[Hh]* ) break;;
					* ) echo "e veya h";;
				esac
			done
		else
			sistem_guncelle_uygula $guncelleme_dosya
		fi
	else
		ryaz 31 "Güncellenecek paket bulunamadı!"
	fi
}

surum_kontrol(){
	local _konum pk_sil _paket
	_paket=$1
	GS_CIKTI="E"
	G_ONAY="H"
	if [ "$2" ]; then
		GS_CIKTI="$2"
	fi
	if [ "$3" ]; then
		G_ONAY="$3"
	fi
	local ksurum surum pkt dusuk yuksek durum
	durum="belirsiz"
	satir=`sed -n '7p' <  $VT/$_paket/META`
	ksurum=${satir:1:${#satir}-1} 
	
	
	_konum=$(talimat_bul $_paket)
	if [ "$_konum" = "-1" ];then
		ryaz 31 "$_paket $_talimat_bulunamadi $_surum_kontrol_iptal"
		pk_sil="e"
		
		for _esgec in `echo ${silme_esgec} | tr " " "\n"`;do
			if [ "${_esgec}" = "${_paket}" ];then
				pk_sil="h"
				break
			fi
		done
		
		if [ "$pk_sil" = "e" ];then
			ryaz 32 "$_paket $_paket_depoda_yok $_siliniyor"
			mps -sz $_paket
		else
			ryaz 32 "$_paket silinmesi es geçildi"
		fi
		
	else
	
		source $_konum/talimat

		dusuk=`echo -e "$ksurum\n$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
		
		if [ "$ksurum" = "$surum" ];then
			durum="guncel"
			[ $GS_CIKTI = "E" ] && ryaz 33 "$_paket sürümü güncel"
			#printf "."
		else
			if [ "$ksurum" = "$dusuk" ];then
				durum="yukselt"
			else
				durum="dusur"
			fi
			gun_onay="h"
			if [ "$durum" != "guncel" ];then
				if [ $G_ONAY = "H" ];then
					while true; do
						printf "\n"
						ryaz 34 "$_paket sürüm $durum""me işlemi uygulanacak. $ksurum <> $surum ";read -p "e veya h-> " eh
						case $eh in
							[Ee]* ) gun_onay="e"; break;;
							[Hh]* ) break;;
							* ) echo "e veya h";;
						esac
					done
				else
					gun_onay="e"
				fi	
				if [ "$gun_onay" = "e" ];then
					if [ -d "$talimatname/temel/$_paket" ]; then
						kurulum_dogrulama_icerik $_paket
						tpk="hayir" 
						paket_sil "$_paket" "evet"
						paket_indir $_paket
						pkt=`cat "$paketdepo""paket.vt" | grep "^$_paket " | cut -d' ' -f3`
						icerik_ekle "$paketdepo$pkt"
					else
						paket_sil "$_paket" "evet"
						paket_inkur_oto $_paket
					fi
					ryaz 33 "$_paket sürüm güncellemesi yapıldı"
					export _paketguncel=1
				else
					ryaz 31 "$_paket sürüm güncellemesi yapılmadı"
					hataloglama "$_paket sürüm güncellemesi yapılmadı"
				fi
			fi
		fi
	fi
	
}

devir_kontrol(){
	local _konum pk_sil _paket
	_paket="$1"
	GS_CIKTI="E"
	G_ONAY="H"
	if [ "$2" ]; then
		GS_CIKTI="$2"
	fi
	if [ "$3" ]; then
		G_ONAY="$3"
	fi
	local kdevir devir pkt dusuk yuksek durum gun_onay
	durum="belirsiz"
	satir=`sed -n '8p' <  $VT/$_paket/META`
	kdevir=${satir:1:${#satir}-1} 
	
	_konum=$(talimat_bul $_paket)
	if [ "$_konum" = "-1" ];then
		ryaz 31 "$_paket $_talimat_bulunamadi $_devir_kontrol_iptal"
		pk_sil="e"
		
		for _esgec in `echo ${silme_esgec} | tr " " "\n"`;do
			if [ "${_esgec}" = "${_paket}" ];then
				pk_sil="h"
				break
			fi
		done
		
		if [ "$pk_sil" = "e" ];then
			ryaz 32 "$_paket $_paket_depoda_yok $_siliniyor"
			mps -sz $_paket
		else
			ryaz 32 "$_paket silinmesi es geçildi"
		fi
		
	else
	
		source $_konum/talimat
		dusuk=`echo -e "$kdevir\n$devir" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
		
		if [ "$kdevir" = "$devir" ];then
			durum="guncel"
			[ $GS_CIKTI = "E" ] && ryaz 33 "$_paket deviri güncel"
			#printf "."
		else
			if [ "$kdevir" = "$dusuk" ];then
				durum="yukselt"
			else
				durum="dusur"
			fi
			gun_onay="h"
			if [ "$durum" != "guncel" ];then
				if [ $G_ONAY = "H" ];then
					while true; do
						printf "\n"
						ryaz 34 "$_paket devir $durum""me işlemi uygulanacak. $kdevir <> $devir ";read -p "e veya h-> " eh
						case $eh in
							[Ee]* ) gun_onay="e"; break;;
							[Hh]* ) break;;
							* ) echo "e veya h";;
						esac
					done
				else
					gun_onay="e"
				fi		
				if [ "$gun_onay" = "e" ];then
					paket_sil "$_paket" "evet"
					paket_inkur_oto $_paket
					ryaz 33 "$_paket devir güncellemesi yapıldı"
				else
					ryaz 31 "$_paket devir güncellemesi yapılmadı"
					hataloglama "$_paket devir güncellemesi yapılmadı"
				fi
			fi
		fi 
	fi
}

surum_karsilastir(){
	local kpaket _konum
	[ "$1" ] && kpaket="$1" || exit 1
	deposurum=$(grep " $kpaket#" /depo/paketler/paket.vt | cut -d' ' -f3 | cut -d'#' -f 2 | cut -d'-' -f1)
	_konum=$(talimat_bul $kpaket)
	if [ "$_konum" = "-1" ];then
		ryaz 31 "$kpaket $_talimat_bulunamadi $_surum_kontrol_iptal"
		exit 1
	fi
	
	source $_konum/talimat
	tsurum=`echo -e "$surum" | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n | head -n1`
	if [ "$tsurum" == "$deposurum" ];then
		echo "esit"
	else
		echo "degil"
	fi
}

surum_devir_kontrol(){
	local _konum pk_sil _paket _durum pk_guncelle
	_paket=$1
	_durum="yaz"
	pk_guncelle="e"
	[ $2 ] && _durum="$2"
	local kdevir devir ksurum surum pkt dusuk yuksek durum
	durum="belirsiz"
	if [ -d "$VT/$_paket" ];then
		satir=`sed -n '7p' <  $VT/$_paket/META`
		ksurum="${satir:1:${#satir}-1}-" 
		satir=`sed -n '8p' <  $VT/$_paket/META`
		kdevir=${satir:1:${#satir}-1}
	else
		ksurum="(none)"
		kdevir=""
	fi
	_konum=$(talimat_bul $_paket)
	if [ "$_konum" = "-1" ];then
		echo "$_paket $_talimat_bulunamadi $_surum_kontrol_iptal"
	else
		for _esgec in `echo ${esgec} | tr " " "\n"`;do
			if [ "${_esgec}" = ${_paket} ];then
				pk_guncelle="h"
				break
			fi
		done
		if [ $pk_guncelle == "e" ];then
			source $_konum/talimat
			if [ "${_durum}" == "yaz" ];then
				echo "$_paket:"
				echo "kurulu sürüm :$ksurum$kdevir"
				echo "depo sürüm   :$surum-$devir"
				echo "--"
			else
				if [ "$ksurum$kdevir" == "$surum-$devir" ];then
					echo "yok"
				else
					echo "var"
				fi
			fi
		else
			echo "$_paket için sürüm-devir kontrolü es geçildi."
		fi
	fi
}

_devir_kontrol_durum(){
	local _konum pk_sil _paket
	_paket="$1"
	local kdevir devir pkt dusuk yuksek durum gun_onay
	durum="belirsiz"
	satir=`sed -n '8p' <  $VT/$_paket/META`
	kdevir=${satir:1:${#satir}-1} 
	
	_konum=$(talimat_bul $_paket)
	if [ "$_konum" = "-1" ];then
		echo "$_paket $_talimat_bulunamadi $_devir_kontrol_iptal"
	else
	
		source $_konum/talimat
		echo "kurulu devir :$kdevir"
		echo "depo devir   :$devir"
	fi
}

talimat_surum_takip(){
	local konum _takip_uzanti
	_takip_uzanti=".takip"
	konum=$(talimat_bul $1)
	if [[ $konum == "-1" || $konum == "0" ]];then
		ryaz 31 "$1 $_talimat_bulunamadi"
		exit 1
	else
		if [ -f "$konum/$1$_takip_uzanti" ];then
			source $konum/$1$_takip_uzanti
			if [ "`type -t surum_takip`" = "function" ];then
				ryaz 32 "$1 paketinin kaynak kod arşivleri inceleniyor..." 
				surum_takip
			else
				ryaz 31 "$1 talimatının sürüm takip işlevi yok!"
			fi
		else
			ryaz 31 "$1 talimatının takip betiği yok!"
		fi
	fi
}

kaynak_kod_indir(){
	local konum adres adres2
	_kk_indir="wget --no-check-certificate -q ${wget_progress}"
	konum=$(talimat_bul $1)
	if [[ $konum == "-1" || $konum == "0" ]];then
		ryaz 31 "$1 $_talimat_bulunamadi"
		exit 1
	else
		source $konum/talimat
		for adres in $kaynak;do
			
			urlkont='(https?|ftp|file)://[-A-Za-z0-9\+&@#/%?=~_|!:,.;]*[-A-Za-z0-9\+&@#/%=~_|]'
			if [[ $adres =~ $urlkont ]];then 
				if [[ $adres =~ "::"  ]];then
					adres2=$(echo $adres | cut -d':' -f-2)
					ryaz 32 "$adres2 indiriliyor."
					$_kk_indir $adres2
				else
					ryaz 32 "$adres indiriliyor."
					$_kk_indir $adres
				fi
			else
				ryaz 32 "$adres kopyalanıyor."
				[ -f $konum/$adres ] && cp  $konum/$adres .
			fi	
		done
	fi
}

paket_derle(){
	#parametre olarak direk konum gelecek
	#eski derleme kalıntılarını temizle
	rm -rf tmp.*
	kaynakdizin_kontrol
	local konum derleme_onay eh bagimd derpaket _gncdurum
	derleme_onay="h"
	if [ -d "$1" ];then
		konum="$1"
		derpaket=`basename $1`
	else
		konum=$(talimat_bul $1)
		if [[ $konum == "-1" || $konum == "0" ]];then
			ryaz 31 "$1 $_talimat_bulunamadi"
			exit 1
		fi
		derpaket="$1"
	fi
	if [ -d "$konum" ];then
		mkdir -p tmp."$derpaket" 
		cp -a $konum/* tmp."$derpaket"/
		cd tmp."$derpaket"
		_kurulu=$(kurulu_kontrol "$derpaket")
		# paket kurulu ise kurulu sürüm-devir depoyla kontrol edilir,gerekirse silinip yenisi derlenir.
		if [ "$_kurulu" = "kurulu" ];then
			_gncdurum=$(surum_devir_kontrol ${derpaket} --durum)
			if [ "${_gncdurum}" == "var" ];then
				echo "Kurulu sürüm depodaki sürümden farklı görünüyor depodaki sürüm ile eşitlemek ister misiniz? "
				surum_devir_kontrol ${derpaket}
				paket_sil ${derpaket}
			fi 
		fi
		
		if [ "$_kurulu" = "kurulu" ] && [ "$zorla_derle" = "yok" ];then
			derleme_onay="h"
		else
			derleme_onay="e"
		fi 
		if [ "$derleme_onay" = "e" ];then
			ryaz 33 "$derpaket" "derleniyor...."
			echo "------------------------"
			mpsd -d 2>&1|tee /tmp/"$derpaket".log
			if ( grep "^=======>" /tmp/"$derpaket".log| tail -1 |grep "ERROR"  > /dev/null);then
				echo "derleme sisteminde hata oluştu -----> " /tmp/"$derpaket".log
				exit 1
			fi
			if [ "$kurulum_onay" = "evet" ];then
				for kpkt in `ls $derpaket* | cut -d'#' -f1`;do
					yerelden_kur "$kpkt#"*
				done	
			fi
			mv *.mps.lz ../
		else
			ryaz 32 "$derpaket $_zaten $_paket_kurulu,yine de derlemek için:
			mps -zd $derpaket"
		fi 
		cd ..
		rm -r tmp."$derpaket"
	else
		ryaz 31 "talimat dosyası bulunamadı."
		hataloglama "talimat dosyası bulunamadı."
	fi

}

##_ bagimlilar() : talimatta yer alan gereklerin listesinin alınması.
bagimlilar(){
	local bagimd konum
	konum=$(talimat_bul $1)
	if [[ $konum != "-1" && $konum != "0" ]];then
		bagimd=`cat $konum/talimat | grep "Gerekler" | cut -d':' -f2`
		bagimd=$(echo "$bagimd" | sed 's/,/ /g')										   
		echo "$bagimd"
	else
		echo "$konum"
	fi
}

ters_bagimli_bilgi(){
	local gtbpaket _sadece_kurulu
	_sadece_kurulu="hepsi"
	gtbpaket=$1
	[ "$2" ] && _sadece_kurulu="$2"
	tbgdosya=$(mktemp)
	grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}\s" $talimatname > $tbgdosya ; 
	grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}\s" $ektalimatname >> $tbgdosya ; 
	grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}$" $ektalimatname >> $tbgdosya ; 
	grep -rli "\s${gtbpaket}\s.*Gerekler\|Gerekler.*\s${gtbpaket}$" $talimatname >> $tbgdosya ; 
	cat $tbgdosya | xargs -I {}  dirname {} | xargs -I {}  basename {} | sort > /tmp/${gtbpaket}.tb.txt
	rm -f $tbgdosya
	[ -f /tmp/${gtbpaket}.tbk.txt ] && rm -f /tmp/${gtbpaket}.tbk.txt
	if [ $_sadece_kurulu = "kurulu" ];then
		for _kurulu_pkt in $(cat /tmp/${gtbpaket}.tb.txt);do
			if [ -d $VT/$_kurulu_pkt ];then 
				echo "$_kurulu_pkt" >> /tmp/${gtbpaket}.tbk.txt
			fi
		done
		[ -f /tmp/${gtbpaket}.tbk.txt ] && cat "/tmp/${gtbpaket}.tbk.txt"
	else
		cat "/tmp/${gtbpaket}.tb.txt"
	fi
	rm -rf $tbgdizin
}

kirik_ters_bagimli_bilgi(){
	ryaz 32 "Aşağıdaki kurulu ters bağımlılıklarda kırılım araması yapılacaktır."
	ters_bagimli_bilgi $1
	ryaz 32 "........"
	talimatlar=$(cat /tmp/$1.tb.txt)
	for tal in $talimatlar;do
		#paket kuruluysa kontrolu yapılacak
		if [ -d "$VT/$tal" ];then
			ryaz 34 "$tal paketi araştırılıyor:"
			kirik_kontrol_paket $tal
			ryaz 34 "--------------------------"
		fi
	done
}

bagimli_bilgi(){
	local bagimd konum bag
	bkonum="`find "$talimatname" -name $1`"
	bekkonum="`find "$ektalimatname" -name $1`"
	if [ $bkonum ];then
		konum=$bkonum
	elif [ $bekkonum ];then
		konum=$bekkonum
	else
		ryaz 31 "$1 talimatı bulunamadı!"
		exit 1
	fi
	bagimd=`cat $konum/talimat | grep "Gerekler" | cut -d':' -f2`
	if [ -n "$bagimd" ]; then
		bagimd=`echo "$bagimd" | sed 's/,/ /g'`
		#sıralı gösterme
		#echo `echo "$bagimd" | sed 's/,/ /g'`
		#kurulu kontrollu gosterim
		for bag in $bagimd;do
			if [ "$2" = "dogrula" ];then
				kurulum_dogrulama_icerik "$bag"
			else
				echo "$bag" "`kurulu_kontrol $bag`"
			fi
		done
	fi
	if [ "$2" = "dogrula" ];then
		kurulum_dogrulama_icerik "$1"
	else
		echo "$1" "`kurulu_kontrol $1`"
	fi
}

bagimli_bilgi_dosyala(){
	rm -f "/tmp/$1.gerekler.liste"
	local bagimd konum bag
	bkonum="`find "$talimatname" -name $1`"
	bekkonum="`find "$ektalimatname" -name $1`"
	if [ $bkonum ];then
		konum=$bkonum
	elif [ $bekkonum ];then
		konum=$bekkonum
	else
		ryaz 31 "$1 talimatı bulunamadı!"
		exit 1
	fi
	bagimd=`cat $konum/talimat | grep "Gerekler" | cut -d':' -f2`
	if [ -n "$bagimd" ]; then
		bagimd=`echo "$bagimd" | sed 's/,/ /g'`
		#sıralı gösterme
		#echo `echo "$bagimd" | sed 's/,/ /g'`
		#kurulu kontrollu gosterim
		for bag in $bagimd;do
			echo $bag >> "/tmp/$1.gerekler.liste"
		done
	fi
	echo "$1" >> "/tmp/$1.gerekler.liste"
	
}

silme_etkilenen_kontrol(){
	paketet="$2"
	mkdir -p /var/lib/pkg/etkilenen
	mkdir -p /var/lib/pkg/etkilenen/$paketet
	local dizin
	for f in $(cat $1) ; do 
		dizin="${f%\'}"
		dizin="${dizin#\'}"
		if [ -d "$dizin" ];then
			for g in `ls "$dizin"` ; do 
				if ! grep -Fxq " '$dizin/$g'" "$1"
				then
					echo "$dizin/$g"
					cp -rf "$dizin/$g" /var/lib/pkg/etkilenen/$paketet
				fi
			done
		fi
	done
}

# güncellemelerin alınması talimatname üzerinden
guncellemeler(){
	#diff --changed-group-format='***%>' --unchanged-group-format='' --new-group-format='+++%>'  \
	#$paketdepo/paket.vt.eski $paketdepo/paket.vt | cut -d' ' -f1 | sort --version-sort
	_mps_guncellenecekler="/tmp/mps.guncellenecekler.liste"
	[ -f $_mps_guncellenecekler ] && rm $_mps_guncellenecekler
	for _paket in $(ls $VT);do
		if [ "$(surum_devir_kontrol ${_paket} x)" = "var" ];then
			echo ${_paket} >> $_mps_guncellenecekler
		fi
	done 
	if [ -f $_mps_guncellenecekler ];then
		echo "guncellenecek liste"
		echo "-------------------"
		cat $_mps_guncellenecekler
	fi
}

# iki dosyanın içerik karşılaştırması yapar.
dosya_karsilastir(){
	if cmp -s "$1" "$2"
	then
	   echo "evet"
	else
	   echo "degil"
	fi
}

# ip bulma
ip_bul(){
	url='[a www.google.com]'
	domain=`echo $url | sed 's-^[^/]*/*\([^/]*\)/\?.*$-\1-'`
	echo "< $domain"
	ipaddr=`ping -c 1 $domain | sed -n 's@^.*(\([0-9]*\.[0-9]*\.[0-9]*\.[0-9]*\).*$@\1@p' | head -1`
	req_url=`echo $url | sed "s-/[^/]\+-/$ipaddr-"`
	echo req_url
}

# renkli mesaj
ryaz() {
	[ -z "$1" ] && return
	: ${color=$1}
	shift
	case $color in
		0*) echo -e "\\033[${color:-38}m$@\\033[39m";;
		*)  echo -e "\\033[1;${color:-38}m$@\\033[0;39m";;
	esac
	unset color
}

log_analiz(){
	local zaman durum
	zaman=$1
	durum=$2
	if [ -f "/var/log/mps/mps.log" ];then
		cat $logdosya | grep "$zaman" | grep "$durum" | cut -d' ' -f3
	else
		ryaz 31 "mps.log bulunamadı!"
		hataloglama "mps.log bulunamadı!"
	fi
}

etkilenen_kurtar(){
	local dizin paket cikti _yaz _yaz_uyari _yaz_tm
	cikti="--renkli"
	if [ "$2" ]; then
		if [ "$2" == "--normal" ];then
			cikti="--normal"
		fi
	fi

	if [ $cikti == "--renkli" ];then
		_yaz="ryaz 32"
		_yaz_tm="ryaz 34"
		_yaz_uyari="ryaz 31"
	else
		_yaz="echo"
		_yaz_tm="echo"
		_yaz_uyari="echo"
	fi
	paket=$1
	if [ -f $VT/$paket/kurulan ];then
		cat $VT/$paket/kurulan | cut -d '>' -f2 > /tmp/$paket.sil
		for f in $(cat /tmp/$paket.sil) ; do 
			dizin="${f%\'}"
			dizin="${dizin#\'}"
			if [ -d "$dizin" ];then
				for g in `ls "$dizin"` ; do 
					if ! grep -Fxq " '$dizin/$g'" "/tmp/$paket.sil"
					then
						if [ -f /tmp/$paket.kurtar ];then
							rm /tmp/$paket.kurtar
						fi
						echo " '$dizin'" >> "/tmp/$paket.kurtar"
					fi
				done
			fi
		done
		if [ -f /tmp/$paket.kurtar ];then
			mv $VT/$paket/kurulan $VT/$paket/ilk.kurulan
			grep -v -F -x -f "/tmp/$paket.kurtar" "/tmp/$paket.sil" > $VT/$paket/kurulan
			$_yaz "$paket etkilenen dosyaları kurtarıldı."
		else
			$_yaz "$paket etkilenen dosyası yok."
		fi
		rm -f /tmp/$paket.sil
	else
		$_yaz_uyari "kurulan paket yok!"
		hataloglama "kurulan paket yok!"
	fi
}

ters_bagimli_kontrol(){
	ters_bagimli_bilgi $1
	cat /tmp/${1}.tb.txt | sort > tersb.liste
	ls $VT/ | sed  "/$1/d" | sort  > simdiki.liste
	comm -12 tersb.liste simdiki.liste
	rm tersb.liste simdiki.liste
}

kurulu_kontrol(){
	local _konum _apaket
	[ -z $1 ] && hata_olustu "_paket_adi_gerekli"
	_apaket=$1
	cikti_renk_ayarla "--normal"
	[ $2 ] && cikti_renk_ayarla "$2"
	if [ -d "$kokdizin$VT/$_apaket" ];then
		$_yaz "kurulu"
		exit 0
	fi
	_konum=$(talimat_bul $_apaket)
	
	if [ "$_konum" = "-1" ];then
		$_yaz_uyari "tanimsiz"
	else
		$_yaz_uyari "degil"
	fi
	exit 1
}

sistem_kur(){
	local spaket
	for spaket in `cat $1`;do 
		./$betikad -ik "$spaket" -kok $2;
	done
}

kaynakdizin_kontrol(){
	if [ ! -d $kaynak_dizin ];then
		mkdir $kaynak_dizin
	fi
}

logdizin_kontrol(){
	if [ ! -d $kokdizin$LOGDIZIN ];then
		mkdir $kokdizin$LOGDIZIN	
	fi
	if [ ! -d $kokdizin$LOGDIZIN/derleme ];then
		mkdir $kokdizin$LOGDIZIN/derleme
	fi
	if [ ! -f $kokdizin$LOGDIZIN/mps.log ];then
		touch $kokdizin$LOGDIZIN/mps.log
	fi
	if [ ! -f $kokdizin$LOGDIZIN/mps-hata.log ];then
		touch $kokdizin$LOGDIZIN/mps-hata.log
	fi
	if [ ! -f $kokdizin$LOGDIZIN/mps-git.log ];then
		touch $kokdizin$LOGDIZIN/mps-git.log
	fi
}

tarihce_dkontrol(){
	if [ ! -d $TARIHCE_DIZIN ];then
		mkdir $TARIHCE_DIZIN
	fi
}

temel_tarihce_kontrol(){
	if [ ! -f $TARIHCE_DIZIN/temel-pkvt.tar.lz ];then
		tarihce_olustur "temel"
	fi
}

tarihce_liste(){
	tarihce_dkontrol
	ls $TARIHCE_DIZIN/

}

tarihce_yap(){
	tarihce_dkontrol
	local t_isim
	if [ "$temel_tarihce" = "evet" ];then
		t_isim="temel"
	else
		t_isim=`date +%m-%d-%y.%H%M%S`
	fi
	tarihce_olustur "$t_isim"
}

tarihce_olustur(){
	bsdtar -P -r -f $TARIHCE_DIZIN/"$1"-pkvt.tar $VT
	lzip -9 $TARIHCE_DIZIN/"$1"-pkvt.tar
}

tarihce_yukle(){
	tarihce_dkontrol
	local islem_onay cikis
	sil_onay="h"
	if [ -f $TARIHCE_DIZIN/"$1-pkvt.tar.lz" ];then
		bsdtar -p -o -C /tmp -xf $TARIHCE_DIZIN/"$1-pkvt.tar.lz" 2>/dev/null
		ls /tmp$VT/ > hedef.pkvt
		ls $VT/ > simdiki.pkvt
		grep -v -F -x -f hedef.pkvt simdiki.pkvt > sil.liste
		grep -v -F -x -f simdiki.pkvt hedef.pkvt > kur.liste
		#rm hedef.pkvt simdiki.pkvt
		rm -r /tmp/var
		cikis=""
		if [ -s sil.liste ];then
			ryaz 32 "silinecekler"
			ryaz 32 "------------"
			cat sil.liste
		fi
		
		if [ -s kur.liste ];then
			ryaz 32 "kurulacaklar"
			ryaz 32 "------------"
			cat kur.liste
		fi
		if [ ! -s sil.liste ] && [ ! -s kur.liste ];then
			ryaz 32 "sistem zaten hedef durumda!"
			exit 1
		fi
		while true; do
			ryaz 34 "otomatik geri dönüşüm başlasın mı?";read -p "e veya h-> " eh
			case $eh in
				[Ee]* ) islem_onay="e"; break;;
				[Hh]* ) break;;
				* ) echo "e veya h";;
			esac
		done
		if [ "$islem_onay" = "e" ];then
			mps -os sil.liste
			mps kurul kur.liste
			mv sil.liste silinenler.liste
			mv kur.liste kurulanlar.liste
			exit 1
		fi
		mv sil.liste sil_iptal.liste	
		mv kur.liste kur_iptal.liste	
	else
		ryaz 31 "ilgili tarihce dosyası bulunamadı!"
		hataloglama "ilgili tarihce dosyası bulunamadı!"
	fi
	[ -f $PWD/hedef.pkvt ] && rm $PWD/hedef.pkvt
	[ -f $PWD/simdiki.pkvt ] && rm $PWD/simdiki.pkvt
}

tarihce_sil(){
	tarihce_dkontrol
	if [ -f $TARIHCE_DIZIN/"$1-pkvt.tar.lz" ];then
		rm -f $TARIHCE_DIZIN/"$1-pkvt.tar.lz"
	else
		ryaz 31 "ilgili tarihce dosyası bulunamadı!"
		hataloglama "ilgili tarihce dosyası bulunamadı!"
	fi
}

sunucu_ayarla(){
	wget -q --spider "$1/paket.vt"
	yenisun="$1"
	if [ $? -eq 0 ]; then
		sed -i.bak 's/^\(sunucu=\).*/\1"xverix\/"/' /etc/mps.conf
		sed -i "s|xverix|$1|" /etc/mps.conf
		mps -sun
	else
		ryaz 31 "Tanımsız paket sunucusu!"
		hataloglama "Tanımsız paket sunucusu!"
	fi
}

loglama(){
	logdizin_kontrol
	echo "$(date +'%F %T') $1" >> "$kokdizin/$LOGDIZIN/mps.log"
}

hataloglama(){
	logdizin_kontrol
	echo "$(date +'%F %T') $1" >> "$kokdizin/$LOGDIZIN/mps-hata.log"
}

indir_talimat_paketle(){
	local dosya _ip _talkonum
	_wget="wget --quiet --no-check-certificate"
	if [ ! -z "$1" ];then dosya=$1;else ryaz 31 "link parametre eksik";exit 1;fi
	if [ ! -z "$2" ];then _ip=$2;else ryaz 31 "ip tipi parametresi eksik";exit 1;fi
	if [ ! -z "$3" ];then _talkonum=$3;else ryaz 31 "talimatname konum parametre eksik";exit 1;fi
	
	urlkont='(https?|ftp|file)://[-A-Za-z0-9\+&@#/%?=~_|!:,.;]*[-A-Za-z0-9\+&@#/%=~_|]'
	if [[ $dosya =~ $urlkont ]];then 
		gdosya=`mktemp`
		if [[ $_ip =~ "-6" ]]; then 
			ryaz 32 "talimat ipv6 linkten cekilecek"
			$_wget $_ip $dosya -O $gdosya
		else
			ryaz 32 "talimat ipv4 linkten cekilecek"
			$_wget $_ip $dosya -O $gdosya
		fi
		dosya=$gdosya
	else
		ryaz 31 "link geçersiz"
		exit 1
	fi
	
	if [ ! -f $dosya ];then
		ryaz 31 "$dosya talimat dosyasi yok!"
		exit 1
	fi
	
	local _isim
	_isim=`grep "^name=" $dosya | head -n1 | cut -d'=' -f 2`
	[ -z "${_isim}" ] && _isim=`grep "^isim=" $dosya | head -n1 | cut -d'=' -f 2`
	if [ ! -n "${_isim}" ]; then
		ryaz 31 "paket ismi degiskeni bulunamadı!"
		exit 1
	fi
	if [ ! -d $_talkonum/${_isim:0:1}/${_isim} ];then
		mkdir -p $_talkonum/${_isim:0:1}/${_isim}
		cp -f $dosya $_talkonum/${_isim:0:1}/${_isim}/talimat
		talimat_degisken_cevrim $_talkonum/${_isim:0:1}/${_isim}/talimat
		ryaz 32 "${_isim} talimatı hazırlandı."
	else
		ryaz 31 "${_isim} talimatı zaten talimatnamede var!"
	fi
}

talimat_degisken_cevrim(){
	_dosya=$1
	if [ -f $_dosya ];then
		sed  -i 's/name=/isim=/g' $_dosya
		sed  -i 's/$name/$isim/g' $_dosya
		sed  -i 's/${name}/${isim}/g' $_dosya
		sed  -i 's/version=/surum=/g' $_dosya
		sed  -i 's/$version/$surum/g' $_dosya
		sed  -i 's/${version}/${surum}/g' $_dosya
		sed  -i 's/${version%.*}/${surum%.*}/g' $_dosya
		sed  -i 's/release=/devir=/g' $_dosya
		sed  -i 's/$release/$devir/g' $_dosya
		sed  -i 's/${release}/${devir}/g' $_dosya
		sed  -i 's/source=/kaynak=/g' $_dosya
		sed  -i 's/build()/derle()/g' $_dosya
		sed  -i 's/build ()/derle()/g' $_dosya
		sed  -i 's/Description:/Tanım:/g' $_dosya
		sed  -i 's/Description=/Tanım:/g' $_dosya
		sed  -i 's/Url=/Url:/g' $_dosya
		sed  -i 's/description:/Tanım:/g' $_dosya
		sed  -i 's/Description :/Tanım:/g' $_dosya
		sed  -i 's/Packager:/Paketçi:/g' $_dosya
		sed  -i 's/packager:/Paketçi:/g' $_dosya
		sed  -i 's/Packagers:/Paketçi:/g' $_dosya
		sed  -i 's/Packager :/Paketçi:/g' $_dosya
		sed  -i 's/Depends on:/Gerekler:/g' $_dosya
		sed  -i 's/Depends:/Gerekler:/g' $_dosya
		sed  -i 's/Depends on :/Gerekler:/g' $_dosya
		sed  -i '/Maintainer:/d' $_dosya
		sed  -i '/Optional:/d' $_dosya
	else
		ryaz 31 "ilgili talimat dosyası bulunamadı."
	fi
}

talimat_olustur(){
if [ "$1" = '?' ];then
	ryaz 34 "kullanım : mps -to paket_ismi"
else
	local isim
	isim=$1
	mkdir -p $isim
	tee "$isim/talimat" > /dev/null <<EOF
# Tanım: paket açıklaması
# Url: paketin ilgili web sayfası
# Paketçi: paketçi
# Gerekler: 
# Grup:

isim=$isim
surum=1
devir=1
kaynak=()

derle() {
	cd \$isim-\$surum
	./autogen.sh
	./configure --prefix=/usr
	make
	make DESTDIR=\$PKG install
}

EOF
	ryaz 34 $isim "talimatı oluşturuldu."
fi
}

git_guncelle() {
	kaynakdizin_kontrol
	gitayar_kontrol
	local _yerel
	
	#git deponun sunucudan güncellenmesi
	ryaz 33 "$_git_guncelleniyor"
	if [ $(sunucu_erisim ${git_sunucu}) = "aktif" ];then
		if [ ! -d ${git_depo} ];then
			git clone ${git_sunucu} ${git_depo}
			#rsync -av ${git_depo}/rootfs/* /
		else
			cd ${git_depo}
			git pull  >& $LOGDIZIN/mps-git.log
			if grep -q "Already\ up-to-date" $LOGDIZIN/mps-git.log; then
				ryaz 32 "$_git_guncel"
			else
				#ryaz 32 `cat $LOGDIZIN/mps-git.log`
				ryaz 32 "$_git_guncellendi"
			fi
			
		fi
	else
		ryaz 31 "${git_sunucu} erişim olumsuz.Uzaktan güncelleme alınamadı."
	fi
	if [ -d ${git_depo} ];then
		# git depodan yerel güncellemelerin yapılması
		#baslangic betiklerinin guncellenmesi
		#rsync -aviz -q --delete ${git_depo}/rootfs/lib/services/* /lib/services/
		[ -d /lib/services/ ] && cp --remove-destination -rf ${git_depo}/rootfs/lib/services/* /lib/services/
		# talimatname ve betiklerin güncellenmesi
		_yerel=$(dirname $talimatname)
		cd ${_yerel}
		rm -rf $talimatname ${_yerel}/bin ${_yerel}/ayarlar
		cp -rf ${git_depo}/talimatname/ ${_yerel}/
		cp -rf ${git_depo}/bin ${_yerel}/
		cp -rf ${git_depo}/ayarlar ${_yerel}/
		
		#ikili dosyaların /usr/bin altına kısayol atılması
		for i in ${_yerel}/bin/*; do
			j=`basename $i`
			if [ ! -L /usr/bin/$j ];then
				ln -sf ${_yerel}/bin/$j /usr/bin/$j
			fi
		done
		#kırık linklerin temizlenmesi
		find -L /usr/bin/* -name . -o -type d -prune -o -type l -exec rm {} +
		find -L ${_yerel}/bin/* -name . -o -type d -prune -o -type l -exec rm {} +
		[ -d /root/bin ] && find -L /root/bin/* -name . -o -type d -prune -o -type l -exec rm {} +
		ryaz 32 "$_yerel_esitlendi"
	else
		ryaz 32 "$_yerel_esitlendi_olumsuz"
	fi
}

git_proje_kur(){
	local proje proj_dizin git_link
	git_link="https://github.com/milisarge"
	proje="$1"
	proj_dizin="/opt"
	mkdir -p $proj_dizin
	if [ -d "$proj_dizin/$proje" ];then
		cd $proj_dizin/$proje
		git pull
		
		if [ -f mops ];then
			. mops
			mops_gun
		fi	
	else
		git clone "$git_link/$proje" "$proj_dizin/$proje"
		cd $proj_dizin/$proje
		
		if [ -f mops ];then
			. mops
			mops_kur
			mops_sil
			mops_gun
		fi
	fi
	
}	

op_kur(){
	local mopsyol mops
	mops=$1
	mopsyol="~/mops/$mops"
	# talimatnameye bak
	if [ -d $mopsyol ]; then
		$mopsyol/talimat kur
	# yerelde ara
	elif [ -f $PWD/"$mops" ]; then
		./"$mops" kur
	else
		ryaz 31 "$1 mops talimatı bulunamadı!"
	fi
 	
}

op_sil(){
	local mopsyol mops
	mops=$1
	mopsyol="~/mops/$mops"
	# talimatnameye bak
	if [ -d $mopsyol ]; then
		$mopsyol/talimat sil
	# yerelde ara
	elif [ -f $PWD/"$mops" ]; then
		./"$mops" sil
	else
		ryaz 31 "$1 mops talimatı bulunamadı!"
	fi
 	
}

servis_kur(){
	cd ${git_depo}/ayarlar/servisler
	if make kur-$1
	then
		 ryaz 32 "$1 servisi kuruldu"
	else
		 ryaz 31 "$1 servisi kurulum olumsuz!!!"
		 hataloglama "$1 servisi kurulum olumsuz!!!"
	fi
	cd -
}

servis_sil(){
	cd ${git_depo}/ayarlar/servisler
	if make sil-$1
	then
		 ryaz 32 "$1 servisi silindi"
	else
		 ryaz 31 "$1 servisi silme olumsuz!!!"
		 hataloglama "$1 servisi silme olumsuz!!!"
	fi
	cd -
}

servisler_kontrol(){
	servisler=`ls ${git_depo}/ayarlar/servisler/mbd/init.d`
	for ser in $(ls /etc/init.d/) ; do 
		if [ ! -f ${git_depo}/ayarlar/servisler/mbd/init.d/$ser ];then
			printf "%12s %s\n" "$ser mbd kaydı bulunamadı!"
		else
			if cmp -s "${git_depo}/ayarlar/servisler/mbd/init.d/$ser" "$ser"
			then
			   printf "%12s %s\n" "$ser" "mbd uyumsuz"
			else
			   #ryaz 32 "$ser mbd +++++"
			   printf "%12s %s\n" "$ser" "mbd +++++"
			fi
		fi	
	done
}

talimat_bilgi(){
	local _konum _apaket
	_apaket=$1
	_konum=$(talimat_bul $_apaket)
	if [ "$_konum" = "-1" ];then
		ryaz 31 "$_apaket $_paket_bulunamadi"
		exit 1
	else
		grep "derle()" -B 12 $_konum/talimat |sed '$ d'
		ryaz 32 "file://$_konum/talimat"
		ryaz 32 "https://raw.githubusercontent.com/milisarge/malfs-milis/master/$(echo $_konum | cut -d'/' -f3-6)/talimat"
	fi
}

talimat_yazdir(){
	local _konum _apaket
	_apaket=$1
	_konum=$(talimat_bul $_apaket)
	if [ "$_konum" = "-1" ];then
		ryaz 31 "$_apaket $_paket_bulunamadi"
		exit 1
	else
		cat $_konum/talimat
	fi
}

sistem_kontrol(){
	paketvt_kontrol
	sunucu_kontrol
}


sunucu_erisim(){
	local _sunucu
	[ $1 ] && _sunucu="$1"
	wget --no-check-certificate -q --spider "${_sunucu}"
	if [ $? -eq 0 ]; then
		echo "aktif"
	else
		echo "pasif"
	fi
}

sunucu_kontrol(){
	local _sunucular=$(echo ${sunucular} | tr " " "\n") 
	for _sunucu in ${_sunucular}; do
		[ $(sunucu_erisim ${_sunucu}/paket.vt) = "aktif" ] && ryaz 32 "${_sunucu} paket sunucu aktif" \
		|| ryaz 31 "${_sunucu} sunucu erişim dışı" 
	done
}	

gitayar_kontrol(){
	if [ ! -f /root/.gitconfig ];then
		[ `which git_ssl_iptal` ] && git_ssl_iptal
		[ `which git_otokimlik` ] && git_otokimlik
	fi
}

kirik_kontrol_sistem(){
	local onek sonek
	onek="'"
	sonek="'"
	for paket in `ls $VT/`
	do	
		ryaz 33 $paket "kontrol ediliyor."
		kirik_kontrol_paket $paket
		ryaz 33 $paket "kontrol edildi."
	done
}

kirik_kontrol_paket(){
	local onek sonek
	onek="'"
	sonek="'"
	for kdosya in `kurulum_dosya_listele $1`
	do	
		dosya=${kdosya#$onek}
		dosya=${dosya%$sonek}
		#echo "${dosya}"
		if [ -f $dosya ];then
			if [[ $(milis-ldd -d $dosya | grep not\ found) ]] ;then 
				echo $kdosya 
			fi
		fi
	done
}

kurulum_dogrulama(){
	for kuruland in `ls $VT`
	do
		if [ ! -f "$VT/$kuruland/kurulan" ]; then
			ryaz 32 "$kuruland hasarlı kurulum tesbiti!"
			rm -r $VT/$kuruland
			paket_indir $kuruland
			yerelden_kur "$paketdepo/$kuruland"*.mps.lz
			ryaz 32  "$kuruland hasarlı kurulum onarıldı."
		fi
	done
}

paket_icerik_dogrulama(){
	local dosyayol kontpaketadi tempmpslz pidanayol
	kontpaketadi="$1"
	if [ -f "$paketdepo/$kontpaketadi#"*.mps.lz ];then
		tempmpslz=$(mktemp)
		if [ -d $2 ];then
			pidanayol="$2"
			tar tf "$paketdepo/$kontpaketadi#"*.mps.lz > $tempmpslz
			IFS=''
			while read dosyayol;do
				if [ ! -f $pidanayol$dosyayol ] && [ ! -d $pidanayol$dosyayol ] && [ $dosyayol != ".MTREE" ] && [ $dosyayol != ".META" ]; then
					ryaz 31 "$pidanayol$dosyayol hasarlı"
					while true; do
						ryaz 34 $kontpaketadi" paketi yenilensin mi?";read -p "e veya h-> " eh
						case $eh in
							[Ee]* ) tekrarkur="evet";agdan_kur "$kontpaketadi";break;;
							[Hh]* ) break;;
							* ) echo "e veya h";;
						esac
					done
				fi
			done < $tempmpslz
		else
			ryaz 31 "$2 kök dizini bulunamadı!"
			exit 1
		fi
	else
		ryaz 31 "$1 paketi bulunamadı!"
		exit 1
	fi
}


kurulum_dogrulama_icerik_tum(){
	ryaz 33  "paket veritabanı yedekleniyor"
	tarihce_yap
	for kurulanpak in `ls $VT`
	do
		if [ -f "$VT/$kurulanpak/kurulan" ]; then
			kurulum_dogrulama_icerik $kurulanpak
			ryaz 32  "$kurulanpak kurulum icerik onarıldı."
		fi
	done
}

chr_yordam() {
  [ "$1" -lt 256 ] || return 1
  printf "\\$(printf '%03o' "$1")"
}

ord_yordam() {
  LC_CTYPE=C printf '%d' "'$1"
}

kurulum_dogrulama_icerik(){
	paketadi="$1"
	onar="hayir"	
	#echo $VT
	#tarihce_yap
	ryaz 33  "$paketadi içeriği kontrol ediliyor."
	if [ -f "$VT/$paketadi/kurulan" ]; then
		ilksatir=`head -n 1 $VT/$paketadi/kurulan`
		if [[ `echo ${ilksatir}` =~ ^‘ ]] ; then 
			ryaz 32 "temel sistem paket kurulan hatası düzeltildi!"
			sed -i 's/‘/'\''\//;s/’/'\''/' $VT/$paketadi/kurulan
		fi
		#for dosyayol in $(cat $VT/$paketadi/kurulan);do
		while read dosyayol; do    
		#for dosyayol in $(<$VT/$paketadi/kurulan);do
			dosyayol=$(echo $dosyayol | sed 's/^.\(.*\).$/\1/')
			netdosyayol="${dosyayol:1:${#dosyayol}-1}"
			if [ ! -f $dosyayol ] && [ ! -d $dosyayol ] ; then
				ryaz 31 "$dosyayol hasarlı"
				onar="evet"
			fi
		done < $VT/$paketadi/kurulan

		if [ $onar = "evet" ];then
			ryaz 34 "$paketadi hasarlı dosya barındırıyor,düzeltilsin mi?";read -p "e veya h-> " eh
			case $eh in
				[Ee]* ) tekrarkur="evet";agdan_kur "$paketadi";;
				[Hh]* ) ryaz 31 "$paketadi pas geçildi.";;
				* ) echo "e veya h";;
			esac
		fi
		
		ryaz 32 "$paketadi kurulum doğrulama tamamlandı." 
	elif [ -d "$VT/$paketadi" ]; then
		cp -rf $VT $VT.yedek
		ryaz 31 "$paketadi hasarlı kurulum tesbiti!"
		#onarma
		rm -r $VT/$paketadi
		paket_indir $paketadi
		yerelden_kur "$paketdepo/$paketadi#"*.mps.lz
		ryaz 32  "$paketadi hasarlı kurulum onarıldı."
	else
		ryaz 31 "$paketadi $_paket_kurulu_degil"
	fi
}

tamir_temel_kurulan(){
	if [ ! -d $VT ] ; then
		ryaz 31 "paket kurulum vt bulunamadı!"
		exit 1
	fi
	for paketadi in `ls $VT`
	do
		sed -i 's/‘/'\''\//;s/’/'\''/' $VT/$paketadi/kurulan
	done
}

depo_paketler_liste(){
	ls $paketdepo*.mps.lz
}

depo_paketler_sil(){
	while true; do
		pktsay="0"
		[[ $(ls  $paketdepo*.mps.lz) ]] && pktsay=$(ls $paketdepo/*.mps.lz | wc -l)
		ryaz 34 "$paketdepo altındaki $pktsay paket silinecek?";read -p "e veya h-> " eh
		case $eh in
			[Ee]* ) rm $paketdepo/*.mps.lz;ryaz 32 "$paketdepo paketler temizlendi."; break;;
			[Hh]* ) break;;
			* ) echo "e veya h";;
		esac
	done	
}

etkilenenler_sil(){
	while true; do
		ryaz 34 "etkilenen önbellek silinecek?";read -p "e veya h-> " eh
		case $eh in
			[Ee]* ) rm -rf /var/lib/pkg/etkilenen;ryaz 32 "etkilenen önbellek temizlendi."; break;;
			[Hh]* ) break;;
			* ) echo "e veya h";;
		esac
	done	
}

kurulum_dosya_listele(){
	cat "$VT/$1/kurulan"
}

# bir dosyanın kurulmuş hangi pakette olduğunu bulur.
kurulan_dosya_bul(){
	grep -rli "$1" "$VT/" | cut -d "/" -f6
}

paketvt_kontrol(){
	mkdir -p /depo/paketler
	if [ ! -f /depo/paketler/paket.vt ];then
		touch /depo/paketler/paket.vt
	fi
}

pvt_olustur(){
	if [ ! -f paket.vt ];then
		touch paket.vt
	fi
	if [ -f "paket.vt" ];then
			mv "paket.vt" "paket.vt.eski"
	fi
	ryaz 32 "paket.vt oluşturuluyor...."
	for paket in `ls *.mps.lz`
	do
		paketad="`echo $paket|cut -d "#" -f1`"
		shaek=`sha1sum $paket`
		
		echo $paketad $shaek  >> paket.vt  
	done
	ryaz 32 "paket.vt oluşturuldu."
}

paketvt_guncelle(){
	local _bakim _sunucular _bakim _sira
	_sunucular=$(echo ${sunucular} | tr " " "\n") 
	_bakim="yok"
	_sira=0
	for pktsunucu in ${_sunucular}; do
	   pkvt=""
	   let _sira=_sira+1
	   if [ ${_sira} = 1 ];then
			pktvt="paket.vt"
	   else
			pktvt="paket${_sira}.vt"
	   fi
	   # sunucu bakım kontrolü
	   [ $(sunucu_erisim "$pktsunucu""paket.vt.yeni") = "aktif" ] &&  _bakim="var"
	   
	   if [ $_bakim = "yok" ];then
		   if [ $(sunucu_erisim "$pktsunucu""paket.vt") = "aktif" ]; then	
				ryaz 32 $pktsunucu
				ryaz 32 "$_paketvt_guncelleniyor" "$paketdepo""$pktvt"
				if [ -f "$paketdepo""$pktvt" ];then
					mv "$paketdepo""$pktvt" "$paketdepo""$pktvt.eski"
				fi
				wget --no-check-certificate -q ${wget_progress} -P "$paketdepo" "$pktsunucu""paket.vt" -O "$paketdepo""$pktvt"
				#rm /tmp/paket.vt*
			else
				ryaz 31 "$pktsunucu paket veritabanı erişim olumsuz."
				hataloglama "paket veritabanı güncelleme olumsuz."
			fi
		else
			ryaz 33 "$pktsunucu paket veritabanı bakımı yapılıyor." 
			ryaz 33 "5dk içinde tekrar deneyiniz."
		fi
	done
	
}

yuzdelik_filtre ()
{
    local flag=false c count cr=$'\r' nl=$'\n'
    while IFS='' read -d '' -rn 1 c
    do
        if $flag
        then
            printf '%c' "$c"
        else
            if [[ $c != $cr && $c != $nl ]]
            then
                count=0
            else
                ((count++))
                if ((count > 1))
                then
                    flag=true
                fi
            fi
        fi
    done
}

listeleri_temizle(){
	[ -f gerek.liste ] && rm -rf  gerek.liste
	[ -f gerek.konum.liste ] && rm -rf  gerek.konum.liste
}

paket_indir(){
	if [ -f "$paketdepo""paket.vt" ];then
		local _ipaket pkt cikti _yaz _yaz_uyari
		[ $1 ] && _ipaket="$1" || hata_olustu "_paket_adi_gerekli"
		cikti="--renkli"
		if [ "$2" ]; then
			cikti="$2"
		fi
		if [ $cikti == "--renkli" ];then
			_yaz="ryaz 32"
			_yaz_uyari="ryaz 31"
		else
			cikti="--normal"
			_yaz="echo"
			_yaz_uyari="echo"
		fi
		local _sunucular _sira
		_sunucular=$(echo ${sunucular} | tr " " "\n") 
		_sira=0
		for pktsunucu in ${_sunucular}; do
			pkvt=""
			let _sira=_sira+1
			if [ ${_sira} = 1 ];then
				pktvt="paket.vt"
			else
				pktvt="paket${_sira}.vt"
			fi
			if [ -f $paketdepo$pktvt ];then
				pkt=`cat "$paketdepo$pktvt" | grep "^${_ipaket} " | cut -d' ' -f3`
				#ryaz 32 "${_ipaket} paketi $pktsunucu altında aranıyor"
				if [ $pkt ];then
					#ryaz 32 "${_ipaket} paketi $pktsunucu altında bulundu"
					ekontdeg=`cat "$paketdepo$pktvt" | grep "^${_ipaket} " | cut -d' ' -f2`
					cpaket="${pkt/'#'/'%23'}"
					#paketin sunucuda varlık kontrolu
					wget -q --spider "$pktsunucu$cpaket"
					if [ $? -eq 0 ]; then	
						$_yaz "${_ipaket} $_indiriliyor"
						if [ "$cikti" == "--normal" ];then
							wget --progress=dot:force -nc --no-check-certificate  -P "$paketdepo" "$pktsunucu$cpaket" 2>&1 | tee /tmp/${_ipaket}_indirme.log | sed -u -n 's/[0-9]*%/&/p'
						else
							wget  --no-check-certificate -nc -q ${wget_progress} -P "$paketdepo" "$pktsunucu$cpaket" #2>&1 | tee /tmp/${_ipaket}_indirme.log
						fi
						
						if [[ "$?" != 0 ]]; then
							$_yaz_uyari "indirme hatalı"
							hataloglama "indirme hatalı"
						else
							mkontdeg=`sha1sum "$paketdepo$pkt" | cut -d' ' -f1`
							if [ "$ekontdeg" != "$mkontdeg" ];then
								$_yaz_uyari "$_shasum_uyumsuzluk,paket tekrar indiriliyor."
								hataloglama "sha1sum uyusmaslik tespit edildi,paket tekrar indiriliyor."
								rm -f "$paketdepo$pkt" 
								paket_indir "${_ipaket}" "$cikti"
							#else
								#$_yaz "$_zaten ${_ipaket} $_paket_onbellek_depoda_var"
							fi
						fi
					else
						$_yaz_uyari "${_ipaket} paketi bulunamadı $pktsunucu dan silinmiş olmalı!"
					fi
				else
					$_yaz_uyari "$pktsunucu ${_ipaket} paketi bulunmuyor!"
				fi
			else
				ryaz 31 "$paketdepo altında $pktvt dosyanız yok.Güncelleme yapınız!"
			fi
		done	
	else
		ryaz 31 "$paketdepo altında paket.vt dosyanız yok.Güncelleme yapınız!"
	fi
}


yerelden_kur(){
	local silme _ypaket
	[ $1 ] && _ypaket=$1 || hata_olustu "_yerel_paket_yok"
	if [ $2 ];then
		if [ "$2" == "-kok" ] && [ -d "$3" ]; then
			kokdizin="$3"
			tekrarkur="evet"
		fi
	fi
	pkontrol=`basename ${_ypaket} | grep -w "mps.lz"`
	if [ ! -z "$pkontrol" -a "$pkontrol" != "" ]; then
		paketad=`echo "${_ypaket}" | cut -d'#' -f1`	
		paketad=`basename $paketad`
		kkont=`kurulu_kontrol "$paketad"`		
		if [ "$kkont" = "degil" ];then
			icerik_ekle "${_ypaket}"
		elif [ "$kkont" = "kurulu" ];then
			if [ "$tekrarkur" = "hayir" ];then
				while true; do
					ryaz 31 "${_ypaket} paketi zaten kurulu silinip kurulsun mu?"
					read -p "e veya h -> " eh
					case $eh in
						[Ee]* ) silme="e"; break;;
						[Hh]* ) break;;
						* ) echo "e veya h";;
					esac
				done
			fi
			if [ "$silme" = "e" ];then
				ryaz 33 "silinecekelerin kontrolu için"
				paket_sil "$paketad"
				icerik_ekle "${_ypaket}"
			fi
		else
			icerik_ekle "${_ypaket}"
			#while true; do
				#ryaz 31 "${_ypaket} paketi talimatname dışı.Yine de kurulsun mu? (kokdizin=$kokdizin) "
				#read -p "e veya h -> " eh
				#case $eh in
				#	[Ee]* ) icerik_ekle "${_ypaket}"; break;;
				#	[Hh]* ) break;;
				#	* ) echo "e veya h";;
				#esac
			#done
		fi
	else
		ryaz 31 "yerelde mps paketi bulunamadı."
	fi
}

agdan_kur(){
	local kontroldeg _cikti _yaz _yaz_tm _yaz_uyari
	_cikti="--normal"
	[ $2 ] && _cikti="$2"
	cikti_renk_ayarla $_cikti
	
	kkont=$(kurulu_kontrol "$1")
	if [ "$kkont" = "degil" ] || [ "$tekrarkur" = "evet" ];then
		paket_indir "$1" "$2"
		if [ $(find $paketdepo -name $1#* | head -1) ];then
			if [ -f $(ls -1t "$paketdepo$1#"* | head -1)  ];then
				if [ "$kurulum_onay" = "evet" ];then
					if [ "$tekrarkur" = "evet" ];then
						paket_sil "$1" "evet"
					fi
					#depo/paketler altında birden fazla sürüm kontrolü yapılır,güncel olan seçilir.
					surumler=$(ls "$paketdepo$1#"* | wc -l)
					if [ $surumler = 1 ];then
						icerik_ekle $(ls "$paketdepo$1#"*) $cikti
					elif [ $surumler -gt 1 ];then
						$_yaz_uyari "$1 paketinin birden fazla sürümü var!"
						kurulacak_guncel_paket=$(ls -1t "$paketdepo$1#"* | head -1)
						$_yaz "$kurulacak_guncel_paket sürümü kuruluyor"
						icerik_ekle $kurulacak_guncel_paket $cikti
					fi
				fi
			else
				$_yaz_uyari "$1 indirme hatası"		
			fi
		fi
	elif [ "$kkont" = "kurulu" ];then
		#ryaz 32 "$1 paketi zaten kurulu!"
		printf "."
	else
		$_yaz_uyari "$1 tanımsız paket veya tekrar kurulum iptali var!"
	fi
}

ayarlar() {
	
	while [ "$1" ]; do
		case $1 in
			### Milis_Paket_Sistemi_Yardim
			### --------------------------
			### mps -i paketismi = sadece paketi indirir,paket kurulmaz.
			-i|--indir)
				kurulum_onay="olumsuz"
				paket_indir "$2" "$3"
				exit 0 ;;
			### mps -ik paketismi = ilgili paketi indirir ve kurar.
			-ik|--inku)
				if [ "$3" == "-kok" ] && [ -d "$4" ]; then
					kokdizin="$4"
				fi
				agdan_kur "$2" ;;
			### mps -ikz|yekur paketismi = ilgili indirip tekrardan kurar,kurulu olmasına bakılmaz.
			-ikz|yekur)
				tekrarkur="evet"  
				agdan_kur "$2" 
				exit 0 ;;
			### mps -k paketismi..mps.lz = yerel dizindeki paketi kurar.
			-k)
				shift
				yerelden_kur "$@" 
				exit 0 ;;
			### mps sil|-s paketismi = ilgili paketi onaylı kaldırır.
			-s|sil)
				if [[ "$2" == "py-"* ]]; then
					pypaket=`echo "$2" | cut -d'-' -f 2`
					echo $pypaket "pip2 ile silinecek"
					pip uninstall $pypaket
					exit 1
				fi
				if [[ "$2" == "py3-"* ]]; then
					pypaket=`echo "$2" | cut -d'-' -f 2`
					echo $pypaket "pip3 ile silinecek"
					pip3 uninstall $pypaket
					exit 1
				fi
				paket_sil "$2" "$3" "$4"
				exit 0 ;;
			### mps zorsil|-sz paketismi = ilgili paketi onaysız kaldırır.
			-sz|zorsil)
				paket_sil "$2" "evet"
				exit 0 ;;	
			### mps gsil paketismi = ilgili paketi güvenli(ters bağımlılıklarına da bakarak) kaldırır.
			gsil)
				paket_sil "$2" "hayir" "evet"
				exit 0 ;;	
			### mps -S paketismi = ilgili paketi altbağımlılıklarını da sorarak kaldırır.
			-S)
				paket_sil_gereklerle "$2" 
				exit 0 ;;
			### mps -Sz paketismi = ilgili paketi altbağımlılıklarını da sormadan sırayla kaldırır.
			-Sz)
				paket_sil_gereklerle "$2" "oto" 
				exit 0 ;;
			### mps ara aranan = paket isimleri ve açıklamalarında anahtar kelime arar.
			-pa|ara)
				paket_ara "$2" 
				exit 0 ;;
			### mps bul aranan = talimat dosyaları içinde anahtar kelimeyi arar.
			bul)
				kelime_bul "$2" 
				exit 0 ;;
			### mps -d paketisimi = sadece paketi bağımlıksız derler.Genelde bağımlılığı olmayan paketler için kullanılır.
			-d|--pkde)
				zorla_derle="yok"
				kurulum_onay="olumsuz"
				paket_derle "$2" 
				exit 0 ;;
			### mps -zd paketismi = Pake kurulu olsa bile derleme yapılır.Bağımlıksız derleme için kullanılır.
			-zd|--pkzde)
				zorla_derle="evet"
				kurulum_onay="olumsuz"
				paket_derle "$2" 
				exit 0 ;;
			### mps odkp paketismi = bir paketi bağımlılık zinciri çıkarıp gereklileri önce kurar gerekli olanları derler,paketler ve kurar.
			odkp)
				if [ -d "$talimatname/temel/$2" ] ; then 
					ryaz 31 "temel paket için odkp kullanılamaz!"
					exit 1
				fi
				oto_derle_kur_paketle "$2" 
				exit 0 ;;
			### mps god paketismi = mps guncelle && mps odkp paketismi.
			god)
				git_guncelle
				oto_derle_kur_paketle "$2" 
				exit 0 ;;
			-dk|--pkdk)
				paket_derle "$2" ;;	
			### mps -derlist liste = verilen liste dosyasındaki paketleri derler.Alt alta yazılı olmalıdır.
			-derlist)
				paket_derle_liste "$2" 
				exit 0;;	
			### mps derle paketismi = paketismi için bağımlılık zinciri çıkarıp gerekli tüm paketleri derler,paketler ve kurar.
			derle)
				paket_derle_kur "$2"
				exit 0 ;;	
			-ok|--pkok)
				paket_kur_oto "$2" ;;
			-okz)
				paket_kur_oto_zorla "$2" ;;	
			-okl|--pkokl)
				paket_kur_liste "$2" ;;
			-oklz)
				paket_kur_liste_zorla "$2" ;;	
			-kh)
				local templist
				templist=`mktemp`
				ls *.mps.lz > $templist
				mps -okz -H $templist ;;
			-ko|--pkko)
				paket_kur_oto2 "$2" ;;	
			-kuruld)
				paket_inkur_liste_direk "$2" ;;
			### mps kurul liste = verilen liste dosyasındaki paketleri kurar.Alt alta yazılı olmalıdır.
			kurul)
				if [ -f $PWD/mps-liste ]; then
					paket_inkur_liste mps-liste
				else
					paket_inkur_liste "$2"
				fi ;;
			-kur)
				paket_inkur_oto "$2" ;;	
			### mps gkur paketismi = git-paketvt günceller ve yerelde mps.lz varsa yereldekini yoksa sunucudan paketi indirip kurar.
			gkur)
				git_guncelle && paketvt_guncelle && paket_inkur_oto "$2" 
				exit 0 ;;		
			### mps kur paketismi = yerelde mps.lz varsa yereldekini yoksa sunucudan paketi indirip kurar.
			kur)
				if [[ "$2" == "py-"* ]]; then
					pypaket=`echo "$2" | cut -d'-' -f 2`
					echo $pypaket "pip2 ile kurulacak"
					pip install $pypaket
					exit 0
				fi
				if [[ "$2" == "py3-"* ]]; then
					pypaket=`echo "$2" | cut -d'-' -f 2`
					echo $pypaket "pip3 ile kurulacak"
					pip3 install $pypaket
					exit 0
				fi
				if [[ "$2" == *"mps.lz"* ]]; then
					if [ "$3" == "-kok" ] && [ -d "$4" ]; then
						kokdizin="$4"
						tekrarkur="evet"
					fi
					yerelden_kur "$2" "$3"
				else
					paket_inkur_oto "$2" "$3"
				fi 
				exit 0 ;;
			### mps kaynak paketismi = ilgili paketin kaynak kodunu indirir.
			kaynak)
				if [ ! "$2" ]; then
					ryaz 31 "paket ismi eksik"
					exit 1
				fi
				kaynak_kod_indir "$2" 
				exit 0 ;;	
			# özel git projesi kurmak için
			gitkur)
				git_proje_kur "$2" ;;
			# otomatik proje sistemi
			# özel git projesi kurmak için
			opk)
				op_kur "$2" ;;
			# özel git projesi silmek için
			ops)
				op_sil "$2" ;;
			### mps serkur paketismi = ilgili paketin servisini kurar
			serkur)
				servis_kur "$2" 
				exit 0 ;;
			### mps sersil paketismi = ilgili paketin servisini siler
			sersil)
				servis_sil "$2" 
				exit 0 ;;
			### mps serkon paketismi = servislerin değişmemezlik kontrolünü yapar.
			serkon)
				servisler_kontrol 
				exit 0 ;;
			### mps kurkos paketismi = ilgili paketin kurulumdan sonraki çalışması gereken betiğini çalıştırır.
			kurkos)
				local pkt
				pkt=$(talimat_bul $2)
				if [ -f  $pkt/$2.kur-kos ];then
					bash $pkt/$2.kur-kos
					exit 0
				else
					ryaz 31 "$2 kur-kos yok!"
					hataloglama "$2 kur-kos yok!"
					exit 1
				fi;;
			### mps koskur paketismi = ilgili paketin kurulumdan önceki çalışması gereken betiğini çalıştırır.
			koskur)
				local pkt
				pkt=$(talimat_bul $2)
				if [ -f  $pkt/$2.kos-kur ];then
					bash $pkt/$2.kos-kur
					exit 0
				else
					ryaz 31 "$2 kos-kur yok!"
					hataloglama "$2 kos-kur yok!"
					exit 1
				fi ;;
			### mps silkos paketismi = ilgili paketin silindikten sonraki çalışması gereken betiğini çalıştırır.
			silkos)
				local pkt
				pkt=$(talimat_bul $2)
				if [ -f  $pkt/$2.sil-kos ];then
					bash $pkt/$2.sil-kos
					exit 0
				else
					ryaz 31 "$2 sil-kos yok!"
					hataloglama "$2 sil-kos yok!"
					exit 1
				fi ;;
			### mps kossil paketismi = ilgili paketin silindikten önceki çalışması gereken betiğini çalıştırır.
			kossil)
				local pkt
				pkt=$(talimat_bul $2)
				if [ -f  $pkt/$2.kos-sil ];then
					bash $pkt/$2.kos-sil
					exit 0
				else
					ryaz 31 "$2 kos-sil yok!"
					hataloglama "$2 kos-sil yok!"
					exit 1
				fi ;;
			### mps -kdl paketismi = ilgili paketin sistemdeki kurulmuş olması gereken dosyalarını gösterir.
			-kdl)
				if [ ! "$2" ]; then
					ryaz 31 "paket ismi eksik"
					hataloglama "(-kdl) paket ismi eksik"
					exit 1
				fi
				kurulu_kontrol_test   "$2" "$3"
				kurulum_dosya_listele "$2" "$3"
				exit 0 ;;	
			### mps -kkp paketismi = ilgili paketin çalışması için eksik olan dosyaları tespit eder.
			-kkp)
				if [ ! "$2" ]; then
					ryaz 31 "paket ismi eksik"
					hataloglama "(-kkp) paket ismi eksik"
					exit 1
				fi
				kirik_kontrol_paket "$2" 
				exit 0 ;;
			### mps kirma paketismi = ilgili paketin sistemde kırdığı paketler tespit edilir.
			kirma)
				if [ ! "$2" ]; then
					ryaz 31 "paket ismi eksik"
					hataloglama "(kirma) paket ismi eksik"
					exit 1
				fi
				kirik_ters_bagimli_bilgi "$2" 
				exit 0 ;;
				
			### mps -kks . = sistemde kurulu tüm paketlerin kırık kontrolünü yapar.Eksik dosyaları tespit eder.
			-kks)
				revdep-rebuild
				#kirik_kontrol_sistem
				exit 0 ;;
			### mps -sdk paketismi = bir paketin güncel sürüm numarasını denetler.
			-sdk)
				if [ ! "$2" ]; then
					ryaz 31 "paket ismi eksik"
					exit 1
				fi
				surum_devir_kontrol "$2" "$3"
				exit 0 ;;
			### mps -dk paketismi = bir paketin güncel devir numarasını denetler.
			-devk)
				if [ ! "$2" ]; then
					ryaz 31 "paket ismi eksik"
					exit 1
				fi
				devir_kontrol_durum "$2" 
				exit 0 ;;
			-pak|--paketle)
				if [ ! "$2" ]; then
					ryaz 31 "paketlenecek dizin ismi eksik"
					hataloglama "paketlenecek dizin ismi eksik"
					exit 1
				fi
				yeniden_paketle "$2" 
				exit 0 ;;
			-psk|--paksiskur)
				if [ ! "$2" ]; then
					ryaz 31 "paket liste yok"
					hataloglama "paket liste yok"
					exit 1
				fi
				if [ ! "$3" ]; then
					ryaz 31 "hedef dizin yok"
					hataloglama "hedef dizin yok"
					exit 1
				fi
				sistem_kur "$2" "$3" 
				exit 0 ;;
			## mps -po . = mps paketlerinin olduğu dizinde paket.vt oluşturur.
			-po)
				pvt_olustur 
				exit 0 ;;
			## mps -os dosya = ilgili dosyadaki altalta sıralı paketleri onaysız siler.
			-os)
				if [ ! "$2" ]; then
					ryaz 31 "silme listesi yok"
					hataloglama "silme listesi yok"
					exit 1
				fi
				paket_sil_oto "$2" 
				exit 0 ;;	
			### mps liste . = sistemde kurulu olan paket listesini verir.
			-kl|liste)
				ls ${kokdizin}${VT} 
				exit 0 ;;
			### mps dliste . = sistemde kurulu olan ama talimatnamede yer almayan paket listesini verir.
			-dkl|dliste)
				ls ${kokdizin}${VT} | sort > /tmp/mps_krl_pkt.txt
				paket_liste | sort > /tmp/mps_tum_pkt.txt
				comm -23 "/tmp/mps_krl_pkt.txt" "/tmp/mps_tum_pkt.txt"
				rm -rf /tmp/mps_krl_pkt.txt
				rm -rf /tmp/mps_tum_pkt.txt
				exit 0 ;;
			### mps paketler grup_ismi = paket deposundaki paket listesini verir.(grup_ismi verilmezse tüm paketler)
			-ptl|paketler)
				 paket_liste "$2" "$3"
				 exit 0 ;;	
			### mps gruplar . = paket deposundaki paket grup listesini verir.
			-pgl|gruplar)
				 paket_grup_liste "$2" 
				 exit 0 ;;	
			### mps -dly paketismi = ilgili paketin genel ve tüm bağımlılık listesini verir,oluşturur.
			-dly|dliste)
				shift
				derleme_listyap "$@" 
				exit 0 ;;	
			### mps -ykp paketismi = ilgili paketin kurulmak istenirse,kurulacak yeni paketleri listeler.
			-ykp)
				#yeni_kurulacak_paketler "$2" 
				derleme_listyap "$2" "--kurulu_atla"
				listeleri_temizle
				exit 0 ;;	
			#sunucu bilgisi alma
			-sun2|sunucu)
				ryaz 32 $sunucu ;;
			### mps sunucular . = paket sunucularını verir.
			-sun|sunucular)
				#ryaz 32 ${sunucular} ;;
				echo ${sunucular} | tr " " "\n" 
				exit 0 ;;
			sun)
				if [ ! "$2" ]; then
					ryaz 31 "sunucu bilgi eksik"
					hataloglama "sunucu bilgi eksik"
					exit 1
				fi
				sunucu_ayarla  "$2" ;;
			### mps -bb paketismi = ilgili paketin gereklerinin durumunu listeler.
			-bb|bagbil)
				bagimli_bilgi "$2" | column -t
				exit 0;;
			-bbdog|bdogrula)
				bagimli_bilgi "$2" "dogrula";;
			-bbd)
				bagimli_bilgi_dosyala "$2" ;;
			### mps -tb talimatismi = ilgili talimata gerek duyan(ters-gerekler) talimatları listeler.
			-tb|tersbag)
				ters_bagimli_bilgi "$2"
				exit 0;;
			-tbk)
				ters_bagimli_kontrol "$2" ;;
			### mps pka paketismi = ilgili paketin depo-gitdepo uyumluluğunu kontrol eder.
			pka)
				paket_analiz "$2" 
				exit 0;;
			### mps pda paketdepo = paketlerin olduğu dizindeki paketlerin depo-gitdepo uyumluluğunu kontrol eder.
			pda)
				paketdepo_analiz "$2"
				exit 0 ;;
			### mps tbilgi paketismi = ilgili paketin talimat bilgilerini verir.
			tbilgi)
				talimat_bilgi "$2"
				exit 0 ;;
			### mps talimat paketismi = ilgili paketin talimatını yazdırır.
			talimat)
				talimat_yazdir "$2"
				exit 0 ;;
			### mps -b paketismi = ilgili paketin kurulum bilgilerini verir.
			-b)
				if [ $2 ];then
					touch "/tmp/mps_paket_bilgi_$2"
					paket_bilgi "$2" "$3"  | tee "/tmp/mps_paket_bilgi_$2"
					if [ $3 ];then
						[ $3 == "--html" ] && paket_bilgi_html "/tmp/mps_paket_bilgi_$2"
					fi
				else
					ryaz 31 "paket ismi eksik"
					exit 1
				fi
				exit 0 ;;
			bil)
				if [ $2 ];then
					if [ $3 ];then
						[ $2 == "surum" ] && paket_bilgi "$3" "--normal"  | sed -n 6p | cut -d':' -f2 | sed 's/^ *//;s/ *$//'
						[ $2 == "devir" ] && paket_bilgi "$3" "--normal"  | sed -n 7p | cut -d':' -f2 | sed 's/^ *//;s/ *$//'
					else
						ryaz 31 "paket ismi eksik"
						exit 1
					fi	
				else
					ryaz 31 "islev ismi eksik"
					exit 1
				fi
				exit 0 ;;
			phtml)
				paketler_depo_html
				exit 0 ;;
			### mps bilgi paketismi = ilgili paketin talimat ve kurulum bilgilerini verir.
			bilgi)
				paket_bilgi "$2" 
				talimat_bilgi "$2"
				exit 0 ;;
			### mps -to talimat_ismi = ilgili talimat ismine göre talimat şablonu oluşturur.
			-to)
				if [ ! "$2" ]; then
					ryaz 31 "talimat ismi eksik"
					hataloglama "talimat ismi eksik"
					exit 1
				fi
				talimat_olustur "$2" 
				exit 0 ;;
			### mps log yyyy-aa-gg olay = mps.log verisi çekmek için (ör: mps log 2017-01-01 silindi)
			log)
				local logyardim
				logyardim="mps log zaman durum (ör: mps log 2017-01-01 silindi)"
				if [ ! "$2" ]; then
					ryaz 31 "zaman parametresi eksik"
					hataloglama "zaman parametresi eksik"
					ryaz 32 $logyardim
					exit 1
				fi
				if [ ! "$3" ]; then
					ryaz 31 "durum parametresi eksik"
					hataloglama "durum parametresi eksik"
					ryaz 32 $logyardim
					exit 1
				fi
				log_analiz "$2" "$3" ;;
			### mps guncelle . = paket veritabanı ve git güncellemesi-talimatname bilgilerini günceller.
			guncelle)
				mps -GG && mps -G 
				exit 0 ;;
			### mps -GG . = git güncellemelerini ve talimatname bilgilerini günceller.
			-Ggit|-GG)
				git_guncelle 
				exit 0 ;;
			### mps -G . = paket veritabanı bilgilerini günceller.
			-G|--pvtg)
				paketvt_guncelle
				mps -kudo 
				exit 0 ;;
			### mps tespit . = tüm sistemin güncellemesi için güncellenecek paket listesini gösterir.
			tespit)
				guncelleme_tespit
				exit 0 ;;
			### mps gun . = güncellenmesi gereken ve depoya yeni eklenen paketleri gösterir.
			gun)
				guncellemeler
				exit 0 ;;
			### mps yukselt . = tüm sistemin güncellemesini gerçekleştirir.
			-GS|yukselt)
				shift
				sistem_guncelle "$@"
				exit 0 ;;
			### mps yukselt2 . = tüm sistemin güncellemesini gerçekleştirir.
			-GS2|yukselt2)
				sistem_guncelle_eski 
				exit 0 ;;
			#tekil temel paket guncelleme-single base package updating
			-tg)
				paket_sil "$2" "evet" &&  mps -ik $2 ;;
			### mps -g paketismi = ilgili paketi tekil günceller.
			-g|--pkgu)
				git_guncelle  && paketvt_guncelle
				if [ ! "$2" ]; then
					ryaz 31 "paket ismi eksik"
					hataloglama "paket ismi eksik"
					exit 1
				fi
				local durum
				durum=`kurulu_kontrol "$2"`
				if [ "$durum" = "kurulu" ]; then
					paket_guncelle "$2"
				elif [ "$durum" = "degil" ]; then
					ryaz 31 "$2 $_paket_kurulu_degil"
					hataloglama "$2 $_paket_kurulu_degil"
				else
					ryaz 31 "$2 $_paket_tanimsiz"
					hataloglama "$_paket_tanimsiz"
				fi
				exit 0 ;;
			#bagimliliklariyla beraber paket guncelleme-package updating with depencies
			-go|--pkgo)
				if [ ! "$2" ]; then
					ryaz 31 "$_paket_adi_gerekli"
					exit 1
				fi
				paket_guncelle_oto "$2";;
			### mps -kk paketismi = ilgili paketin kurulu olma durumunu gösterir.
			-kk)
				shift
				kurulu_kontrol "$@"
				exit 0 ;;
			-kudo)
				kurulum_dogrulama 
				exit 0 ;;
			-kdi|dogrula)
				if [ ! "$2" ]; then
					ryaz 31 "$_paket_adi_gerekli"
					exit 1
				fi
				kurulum_dogrulama_icerik "$2" ;;
			-pid|pdogrula)
				kokdzn=""
				if [ ! "$2" ]; then
					ryaz 31 "$_paket_adi_gerekli"
					exit 1
				elif [ ! "$3" ]; then
					kokdzn="/"
				else
					kokdzn="$3"
				fi
				paket_icerik_dogrulama "$2" "$kokdzn";;
			-kdit|tumdogrula)
				kurulum_dogrulama_icerik_tum 
				exit 0 ;;
			-kdk)
				etkilenen_kurtar $2 ;;
			### mps -suko . = sunucuların erişim kontrolünü yapar.
			-suko)
				sunucu_kontrol 
				exit 0 ;;
			### mps -pot . = talimatı olup ta paketi henüz depoda yer almayan talimatları listeler.
			-pot)
				paketsiz_talimatlar 
				exit 0 ;;
			-dpl|deplist)
				depo_paketler_liste 
				exit 0 ;;
			### mps depsil . = depo/paketler altındaki paket önbelleğini temizler.
			-dps|depsil)
				depo_paketler_sil 
				exit 0 ;;
			### mps etksil . = /var/lib/pkg/etkilenen altındaki kurtarılmış paket önbelleğini temizler.
			-etks|etksil)
				etkilenenler_sil 
				exit 0 ;;
			### mps link url_adres = verilen url adresindeki talimatı ektalimatname/topluluk altına indirir.
			link)
				mkdir -p $ektalimatname/topluluk
				indir_talimat_paketle $2 "-4" "$ektalimatname/topluluk"
				exit 0 ;;
			### mps ti url_adres = verilen url adresindeki talimatı talimatname/genel altına indirir.
			ti)
				indir_talimat_paketle $2 "-4" "$talimatname/genel"
				exit 0 ;;
			-cf|--config-file)
				if [ ! "$2" ]; then
					echo "ayardosyası gerek $1"
					exit 1
				fi
				ayar_dosyasi="$2"
				shift ;;
			### mps -hp aranan = ilgili aranan ifadenin hangi paketlerde olabileceğini listeler.
			-hp)
				if [ ! "$2" ]; then
					ryaz 31 "paket ismi eksik"
					exit 1
				fi
				kurulan_dosya_bul "$2"
				exit 0 ;;
			### mps tgs talimat = ilgili talimatın kaynak kodunun yeni sürümü olup olmadığını kontrol eder.
			tgs)
				if [ ! "$2" ]; then
					ryaz 31 "talimat ismi eksik"
					exit 1
				fi
				talimat_surum_takip "$2"
				exit 0 ;;
			### mps -tro . = tarihçe noktası oluşturur.
			-tro)
				tarihce_yap 
				exit 0 ;;
			### mps -trot . = temel tarihçe noktası oluşturur.
			-trot)
				temel_tarihce="evet"
				tarihce_yap 
				exit 0 ;;
			### mps -try tarihce_nokta = tarihçe noktasına göre paketleri yükler-siler.
			-try)
				if [ ! "$2" ]; then
					ryaz 31 "tarihce dosyasi eksik $1"
					hataloglama "tarihce dosyasi eksik $1"
					exit 1
				fi
					tarihce_yukle "$2"
					shift ;;
			### mps -trl . = tarihçe noktalarını listeler.
			-trl)
				tarihce_liste ;;
			### mps tdc talimat_dosyası = ilgili talimat dosyasının Türkçe değişken çevrimini yapar.
			tdc)
				talimat_degisken_cevrim $2
				exit 0 ;;
			-tamir-tk)
				tamir_temel_kurulan ;;
			### mps dos . = derleme ortamını sıfırlar.temel tarihçeye geri döner.
			dos)
				tarihce_yukle "temel" 
				exit 0 ;;
			-trs)
				if [ ! "$2" ]; then
					ryaz 31 "parametre eksik $1"
					hataloglama "parametre eksik $1"
					exit 1
				fi
					tarihce_sil "$2"
					shift ;;
			### mps itest islev_ismi = mps içindeki işlevlerin testi için kullanılmaktadır.
			itest)
				if [ $2 ];then
					_islev="$2"
					if [ "`type -t $_islev`" == "function" ];then
						shift;shift
						$_islev $@
					else
						echo "$_islev işlevi bulunamadı"
					fi
				else
					echo "test edilecek işlev parametresi eksik"
				fi
				exit 0 ;;
			### mps -v . = mps sürüm bilgisini gösterir.
			-v)
				ryaz 33 "$betikad $versiyon  $iletisim $shelltip" 
				#echo  "$betikad $versiyon  $iletisim $shelltip" | bilgi_kutusu
				exit 0 ;;
			
			-y|-h|yardim)
				yardim_icerik
				exit 0 ;;
			*)
				ryaz 31 "Geçersiz Parametre!  --> mps yardim "
				exit 0 ;;
		esac
		shift
	done
}
yardim_icerik(){
	cat $betikyol | sed -e 's/^[ \t]*//' | sed -n '/^###/p'  | sed  '/ /s/^###//g' | awk '{split($0,a,"=");  printf "%-6s %-13s %-18s %-40s \n",$1,$2,$3,a[2]}'
}

bilgi_kutusu() {
	: ${title='Bilgi'}
	: ${icon=dialog-information}

	yad --title="$title" --window-icon="$icon" \
		--geometry='600x220+0-24' --fore='#ffffff' --back='#000033' \
		--text-info --fontname=monospace --wrap $opts \
		--button='gtk-close:1'
}

ana(){
if [ `id -u` = 0 ] ; then	
	ayarlar "$@"
else
	sudo mps "$@"
fi
}
ana "$@"


#31 kirmizi
#32 yesil
#33 sari
#34 mavi
#34 mor