func setup() {
	var dir string
	var username string
	var password []byte

	fmt.Println("Setup")
	fmt.Println("--------------------")
	fmt.Println("Bitte gib deine CampusOffice daten ein.")
	fmt.Println("Deine Zugangsdaten werden verschlüsselt auf deinem Computer abgelegt.")

	fmt.Printf("MatrNr: ")
	fmt.Scanln(&username)
	fmt.Printf("Passwort: ")
	password = gopass.GetPasswdMasked()

	for !login(string(username), string(password)) {
		fmt.Println("Falche MatrNr oder falsches Passwort!")

		fmt.Printf("MatrNr: ")
		fmt.Scanln(&username)
		fmt.Printf("Passwort: ")
		password = gopass.GetPasswdMasked()
	}

	fmt.Println("Erfolgreich eingeloggt")
	db.set_encrypted_setting(e, "username", username)
	db.set_encrypted_setting(e, "password", string(password))

	fmt.Println("Bitte gib den Speicherort an, an dem deine iCal exportiert werden soll.")
	fmt.Println("Beispiele:")
	fmt.Println("Windows: C:\\Users\\Benutzer\\Dropbox")
	fmt.Println("Linux: /home/Benutzer/Dropbox")

	fmt.Printf("Speicherort: ")
	fmt.Scanln(&dir)

	_, err := os.Stat(dir)
	for err != nil {
		if os.IsNotExist(err) {
			log.Print(err)
			fmt.Printf("Der Speicherort %s existiert nicht.\n", dir)
			fmt.Println("Bitte gibt einen gültigen Speicherort an")
		} else {
			fmt.Println("Es ist ein Fehler aufgetreten.")
			fmt.Println("Bist du sicher, dass du Zugriffsberechtigungn auf diesen Ordner hast?")
		}
		fmt.Printf("Speicherort: ")
		fmt.Scanln(&dir)
		_, err = os.Stat(dir)
	}
	db.set_setting("dir", dir)

	db.set_setting("setup", "1")
	fmt.Println("Setup abgeschlossen")
}

func Login(args []string, opts map[string]interface{}) {
	user := &userInfo{CurDir: "/"}
	if len(args) == 3 {
		user.Bucket = args[0]
		user.Username = args[1]
		user.Password = args[2]
	} else {
		fmt.Printf("ServiceName: ")
		fmt.Scanf("%s\n", &user.Bucket)
		fmt.Printf("Operator: ")
		fmt.Scanf("%s\n", &user.Username)
		fmt.Printf("Password: ")
		b, err := gopass.GetPasswdMasked()
		if err == nil {
			user.Password = string(b)
		}
	}

	if _, err := NewFsDriver(user.Bucket, user.Username,
		user.Password, user.CurDir, 10, nil); err != nil {
		fmt.Fprintf(os.Stderr, "failed to log in. %v\n", err)
		os.Exit(-1)
	}

	// save
	conf.UpdateUserInfo(user)
	conf.Save(confname)
}

func getAndVerifyMaster(master string) string {
	// prompt for a master password if necessary
	if len(master) == 0 {
		// get master password from environment, or from keyboard
		if s := os.Getenv("LETMEIN_MASTER"); s != "" {
			master = s
		} else {
			fmt.Printf("Master password: ")
			master = string(gopass.GetPasswdMasked())
			if len(master) == 0 {
				fmt.Fprintf(os.Stderr, "master password is required")
				os.Exit(1)
			}
		}
	}

	// validate the master password
	if len(master) < minMasterLength || len(master) > maxMasterLength {
		fmt.Fprintf(os.Stderr, "master password must be between %d and %d characters\n", minMasterLength, maxMasterLength)
		os.Exit(1)
	}
	for _, r := range master {
		if r < minChar || r > maxChar {
			fmt.Fprintf(os.Stderr, "master password contains an illegal character\n")
			os.Exit(1)
		}
	}

	return master
}

// SetupDb creates a new database or opens an existing one at a given directory.
// This will prompt the user to set a password if the database is being created.
func SetupDb(path string) (*Db, error) {
	imageDb, err := imagedb.NewDb(path)
	if err != nil {
		return nil, err
	}

	res := Db{imageDb, sync.RWMutex{}, filepath.Join(path, "config.json"), Config{}}
	saveConfig := false

	if res.loadConfig() != nil {
		saveConfig = true
	}
	if res.config.PasswordHash == "" {
		fmt.Print("Setup new password: ")
		pass := gopass.GetPasswdMasked()
		res.config.PasswordHash = HashPassword(string(pass))
		saveConfig = true
	}
	if res.config.MaxFileSize == 0 {
		res.config.MaxFileSize = DefaultMaxFileSize
		saveConfig = true
	}
	if res.config.MaxUploadsPerHour == 0 {
		res.config.MaxUploadsPerHour = DefaultMaxCountPerHour
		saveConfig = true
	}

	if saveConfig {
		if err := res.saveConfig(); err != nil {
			return nil, err
		}
	}

	return &res, nil
}

// ReadPassword reads password from standard input without echoing the characters.
// If mask is true, each chracter will be represented with astericks '*'. Note that
// this only works as expected when the standard input is a terminal.
func (s *Shell) ReadPassword(mask bool) string {
	fmt.Fprint(s.writer, s.prompt)
	if mask {
		return string(gopass.GetPasswdMasked())
	}
	return string(gopass.GetPasswd())
}

func (adc *ADC) AskCredentials() {
	fmt.Print("ADC username: ")
	fmt.Scanf("%s\n", &adc.username)

	fmt.Print("ADC password: ")
	adc.password = string(gopass.GetPasswdMasked())
}

func GetPasswd() string {
	fmt.Printf("Password: ")
	p, err := gopass.GetPasswdMasked()
	if err != nil {
		log.Fatal(err)
	}
	return string(p)
}

// Password prompt with mask.
func PasswordMasked(prompt string, args ...interface{}) string {
	fmt.Printf(prompt+": ", args...)
	var buf, err = gopass.GetPasswdMasked()
	if err != nil {
		return ""
	}
	s := string(buf[0:])
	return s
}

// ReadPassword reads password from standard input without echoing the characters.
// If mask is true, each character will be represented with asterisks '*'. Note that
// this only works as expected when the standard input is a terminal.
func (s *Shell) ReadPassword(mask bool) string {
	if s.showPrompt {
		s.Print(s.prompt)
	}
	if mask {
		return string(gopass.GetPasswdMasked())
	}
	return string(gopass.GetPasswd())
}

func getPassword() []byte {
	passFromEnv := os.Getenv("SCONSIFY_PASSWORD")
	if passFromEnv != "" {
		fmt.Println("Reading password from environment variable SCONSIFY_PASSWORD.")
		return []byte(passFromEnv)
	}
	fmt.Print("Password: ")
	return gopass.GetPasswdMasked()
}

func (this *MergeAccount) input_SrcSeed() string {
	fmt.Printf(this.infoStrings[this.languageIndex][MA_INFO_INPUT_SOURCE_SEED])

	input := gopass.GetPasswdMasked()
	if publicdefine.VerifySAddress(string(input)) == nil {
		return string(input)
	}
	return ""
}

func (this *AccountInfoPayment) input_SrcSeed() string {
	fmt.Printf(this.infoStrings[this.languageIndex][AIP_INFO_INPUT_PRIVATE_SEED])

	input := gopass.GetPasswdMasked()
	if publicdefine.VerifySAddress(string(input)) == nil {
		return string(input)
	}
	return ""
}

// PasswordMasked prompt with mask.
func PasswordMasked(prompt string, args ...interface{}) string {
	fmt.Printf(prompt, args...)

	b, err := gopass.GetPasswdMasked()
	if err != nil {
		panic(err)
	}

	return string(b)
}

func main() {
	fmt.Print("Email/username: ")
	user := readLine()
	fmt.Print("Password: ")
	pass, err := gopass.GetPasswdMasked()
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	fmt.Println()
	fmt.Println("Authenticating...")

	sess, err := fbmsgr.Auth(user, string(pass))
	if err != nil {
		fmt.Fprintln(os.Stderr, "Failed to login:", err)
		os.Exit(1)
	}

	fbid := promptChat(sess)

	fmt.Print("Destination filename: ")
	file := readLine()

	fmt.Println("Downloading messages...")
	var actions []map[string]interface{}

	actionChan, errChan := sess.FullActionLog(fbid, nil)
	for action := range actionChan {
		actions = append(actions, action.RawFields())
		fmt.Printf("\rGot %d actions...", len(actions))
	}
	fmt.Printf("\rTotal of %d actions...\n", len(actions))

	if err := <-errChan; err != nil {
		fmt.Fprintln(os.Stderr, "Fetch error:", err)
	}

	// Sort the actions chronologically.
	for i := 0; i < len(actions)/2; i++ {
		actions[i], actions[len(actions)-(i+1)] = actions[len(actions)-(i+1)], actions[i]
	}

	encoded, err := json.MarshalIndent(actions, "", "  ")
	if err != nil {
		fmt.Fprintln(os.Stderr, "Serialization failed:", err)
		os.Exit(1)
	}

	if err := ioutil.WriteFile(file, encoded, 0755); err != nil {
		fmt.Fprintln(os.Stderr, "Failed to write file:", err)
		os.Exit(1)
	}
}

func promptForString(field string, r io.Reader, show bool) (result string, err error) {
	fmt.Printf("Please enter %s: ", field)
	if show {
		_, err = fmt.Fscan(r, &result)
	} else {
		var data []byte
		data, err = gopass.GetPasswdMasked()
		result = string(data)
	}
	return result, err
}

// main is the entry point for this app.
func main() {
	log.SetFlags(log.Lshortfile)
	// Command line flags
	configPtr := flag.String("config", "", "Config name to use.")
	userPtr := flag.String("user", "", "Username to use for sshing.")
	aConfigs := gsh.LoadConfigs()
	strConfig := ""
	flag.Parse()

	// Check command line options
	if len(*configPtr) > 0 {
		strConfig = *configPtr
		fmt.Printf("Using config: %s\n", strConfig)
	} else {
		strConfs := ""
		for _, conf := range aConfigs {
			if len(strConfs) > 0 {
				strConfs += ", "
			}
			strConfs += conf.Name
		}
		strConfig = readLine(fmt.Sprintf("Select configuration to load (%s): ", strConfs))
	}
	for _, conf := range aConfigs {
		if strings.EqualFold(conf.Name, strConfig) {
			gsh.CurrentConfig = &conf
			break
		}
	}
	if gsh.CurrentConfig == nil {
		log.Fatalf("Unable to load config %s", strConfig)
	}
	if len(*userPtr) > 0 {
		resources.SshUser = *userPtr
		fmt.Printf("Using user: %s\n", resources.SshUser)
	} else {
		resources.SshUser = readLine("Please enter the ssh user to use: ")
	}
	fmt.Printf("Password:")
	resources.SshPwd = string(gopass.GetPasswdMasked())

	// other service endpoints
	http.HandleFunc("/hosts", resources.HostsResourceHandler)
	http.HandleFunc("/operations", resources.OperationsResourceHandler)
	http.HandleFunc("/subscribe/", resources.SubscribeResourceHandler)
	// static files
	http.Handle("/", http.FileServer(http.Dir("webroot")))

	//log.Fatal(http.ListenAndServe(":8080", nil))
	fmt.Println("gSSH Utilities started and serving data.")
	log.Fatal(http.ListenAndServeTLS(":7443", "cert.pem", "key.pem", nil))
}

func getPasswd(prompt string) (string, error) {
	for {
		fmt.Print(prompt)
		pass, err := gopass.GetPasswdMasked()
		if err != nil {
			return "", fmt.Errorf("Failed to read password")
		}
		if 0 < len(pass) {
			return string(pass[:]), nil
		}
	}

}

func main() {
	var domain, salt, master, note string = "", "", "", ""
	var pass_length int = 14

	if len(os.Args) == 1 {
		fmt.Printf("Usage: %s domain [password-length]\n", os.Args[0])
		os.Exit(1)
	}

	if len(os.Args) > 1 {
		// We do have domain
		domain = strings.TrimSpace(os.Args[1])
		display_notes(domain)
	}

	if len(os.Args) > 2 {
		// We do have password length
		p_length, err := strconv.Atoi(os.Args[2])
		if err != nil {
			fmt.Printf("Password Length should be a number\n")
			os.Exit(1)
		}
		pass_length = p_length
	}

	reader := bufio.NewReader(os.Stdin)

	fmt.Printf("Enter salt. Hit enter to leave it blank: ")
	salt, _ = reader.ReadString('\n')
	salt = strings.TrimRight(salt, "\n")

	fmt.Printf("Enter note to save. Hit enter to leave it blank: ")
	note, _ = reader.ReadString('\n')
	note = strings.TrimRight(note, "\n")

	if len(note) > 0 {
		add_note(domain, note)
	}

	fmt.Printf("Enter Master password. Hit enter to abort: ")
	master = string(gopass.GetPasswdMasked()[:])

	if len(master) == 0 {
		os.Exit(1)
	}

	password := gen_pwd(domain+salt, master)[:pass_length]
	clipboard.WriteAll(password)
	fmt.Println(password, "copied to your clipboard")
}

func readLine(prompt string, private bool) (string, error) {
	fmt.Fprintf(os.Stdout, prompt)
	var line string
	var err error

	if private {
		line = string(gopass.GetPasswdMasked())
	} else {
		line, err = in.ReadString('\n')
		if err != nil {
			return "", err
		}
	}
	return strings.Trim(line, "\n"), nil
}

func Login(args ...string) {
	config := &Config{CurDir: "/"}

	fmt.Printf("ServiceName: ")
	fmt.Scanf("%s\n", &config.Bucket)
	fmt.Printf("Operator: ")
	fmt.Scanf("%s\n", &config.Username)
	fmt.Printf("Password: ")
	config.Password = string(gopass.GetPasswdMasked())

	if err := saveConfig(config); err != nil {
		fmt.Fprintf(os.Stderr, "login: %v\n\n", err)
		os.Exit(-1)
	}
}