Golang PacketStd.SendPacket方法代码示例

func (fs *FileSession) FileSession_Authenticate(p packet.PacketStd) {
	fmt.Println("Authenticating new user")
	db, error := sql.Open("sqlite3", fs.RootDir+"/gypo.db")

	if error != nil {
		fmt.Println(error.Error())

	} else {
		username := p.Data[:strings.Index(p.Data, "|")]
		password := p.Data[strings.Index(p.Data, "|")+1:]
		fmt.Println("username: " + username + " - password: " + password)
		error := db.QueryRow("SELECT id FROM users WHERE username = ? AND password = ?", username, password).Scan(&fs.User.Id)

		if error != nil {
			newPacket := packet.PacketStd{packet.Packet{"text", "login"}, "USER_AUTHENTICATED_FALSE"}
			go newPacket.SendPacket(fs.Connection)
			fmt.Println("auth fail")

		} else {
			newPacket := packet.PacketStd{packet.Packet{"text", "login"}, "USER_AUTHENTICATED_TRUE"}
			go newPacket.SendPacket(fs.Connection)
			//send session to channel to invoke session container insertion
			fs_asSession := Session{fs.User, fs.SessionChan, fs.CloseSession, fs.RootDir} //morphs FileSession to Session
			fs.SessionChan <- fs_asSession

			fmt.Println("auth success, id set to ", fs.User.Id)

			//creates user folder if needed
			error = os.Chdir(fs.RootDir + "/user-" + strconv.Itoa(fs.User.Id) + "/")

			if error != nil {
				fmt.Println("Creating folder for user: ", fs.User.Id)
				error := os.MkdirAll(fs.RootDir+"/user-"+strconv.Itoa(fs.User.Id), 07777) //liberal chmod

				if error != nil {
					fmt.Println(error.Error())
				}

			} else {
				os.Chdir("..") //moves back up
			}

			fs.RootDir = fs.RootDir + "/user-" + strconv.Itoa(fs.User.Id) + "/"

			//moves RootDir to session working directory
			_ = os.Chdir(fs.RootDir)
			fmt.Println("current working directory: " + fs.RootDir)

			//initializes tempHash
			fs.tempHash = make(map[string]packet.PacketStd)
		}
		db.Close()
	}
}

func (fs *FileSession) textHandler(incomingPacket packet.PacketStd) {

	//closes connection and removes session if client /quit
	if incomingPacket.Data == "quit" {
		fs.CloseSession = true
		fs.Connection.Close()
		fmt.Println("session " + strconv.Itoa(fs.User.Id) + " closed connection")

		//send session to channel to invoke container deletion
		fs_asSession := Session{fs.User, fs.SessionChan, fs.CloseSession, fs.RootDir} //morphs FileSession to Session
		fs.SessionChan <- fs_asSession
	}

	newPacket := packet.PacketStd{packet.Packet{"text", ""}, "SEND_TEXT_DONE"}
	go newPacket.SendPacket(fs.Connection)
}

func (fs *FileSession) hashHandler(incomingPacket packet.PacketStd) {

	//connects to db to comapre hash
	db, error := sql.Open("sqlite3", "../gypo.db")

	if error != nil {
		fmt.Println(error.Error())
	} else {
		var hash string
		error := db.QueryRow("SELECT hash FROM files WHERE path = ? AND filename = ? AND user_id = ?", incomingPacket.Name[:strings.LastIndex(incomingPacket.Name, "/")+1], incomingPacket.Name[strings.LastIndex(incomingPacket.Name, "/")+1:], fs.User.Id).Scan(&hash)

		if error != nil {
			newPacket := packet.PacketStd{packet.Packet{"hash", incomingPacket.Name}, "SEND_FILE_TRUE"}
			go newPacket.SendPacket(fs.Connection)
			fmt.Println("file not exist, send file")

			//adds hash to tempHash, if file recieve is successful; tempHash is dumped to db
			incomingPacket.Data = "0" + incomingPacket.Data //adds '0' to indicate INSERT(new file)
			fs.tempHash[incomingPacket.Name] = incomingPacket

		} else if hash != incomingPacket.Data {
			newPacket := packet.PacketStd{packet.Packet{"hash", incomingPacket.Name}, "SEND_FILE_TRUE"}
			go newPacket.SendPacket(fs.Connection)
			fmt.Println("hash different, send file")

			//adds hash to tempHash, if file recieve is successful; tempHash is dumped to db
			incomingPacket.Data = "1" + incomingPacket.Data //adds '1' to indicate UPDATE(existing file)
			fs.tempHash[incomingPacket.Name] = incomingPacket

		} else if hash == incomingPacket.Data {
			newPacket := packet.PacketStd{packet.Packet{"hash", incomingPacket.Name}, "SEND_FILE_FALSE"}
			go newPacket.SendPacket(fs.Connection)
			fmt.Println("hash same, no send file")

		}
		db.Close()
	}
}

func (fs *FileSession) ReadFromSocket() {
	fs.CloseSession = false
	var recievedSize bool
	var readBuffer [4096]byte
	var incomingBytes int

	//read til session closes
	for fs.CloseSession == false {
		chunkSize, error := fs.Connection.Read(readBuffer[:10])

		//checks if first 10 bytes are packet size integer
		if chunkSize == 10 {
			incomingBytesStr := string(readBuffer[:10])
			incomingBytesStr = strings.Trim(incomingBytesStr, " ")
			incomingBytes, error = strconv.Atoi(incomingBytesStr)
			//check if first 11 bytes are readable as int
			if error == nil {
				fmt.Println("incoming package size: ", incomingBytes)
				recievedSize = true
			} else {
				fmt.Println(error.Error())
				recievedSize = false
			}

			//variable to hold number of bytes written to buffer
			writtenBytes := 0

			for recievedSize == true {
				if writtenBytes < incomingBytes {

					chunkSize, _ = fs.Connection.Read(readBuffer[writtenBytes:incomingBytes])
					writtenBytes = writtenBytes + chunkSize
					fmt.Println("recieved: ", writtenBytes, " / ", incomingBytes, " from: "+strconv.Itoa(fs.User.Id))

					//check if all bytes have been written to buffer
					if writtenBytes == incomingBytes {
						recievedSize = false
						data := readBuffer[:incomingBytes]
						fmt.Println("packet done, data size: ", len(data))
						var incomingPacket packet.PacketStd
						error = json.Unmarshal(data, &incomingPacket)

						if error == nil {
							fmt.Println("json parse successful - data: ", incomingPacket.Data, " | contentType: "+incomingPacket.ContentType+" | name: "+incomingPacket.Name+"\n")

							//authenticates user
							if fs.User.Id < 0 {
								if incomingPacket.ContentType == "text" && incomingPacket.Name == "login" {
									fs.FileSession_Authenticate(incomingPacket)
								} else {
									newPacket := packet.PacketStd{packet.Packet{"text", ""}, "You need to login first"}
									go newPacket.SendPacket(fs.Connection)
								}

							} else {
								//basic string packets
								if incomingPacket.ContentType == "text" {
									fs.textHandler(incomingPacket)

									//hash packets
								} else if incomingPacket.ContentType == "hash" {
									fs.hashHandler(incomingPacket)

									//file packets
								} else if incomingPacket.ContentType == "file" {
									fs.fileHandler(incomingPacket)

									//filesystem events through FSEvents wrapper Watchdog
								} else if incomingPacket.ContentType == "fs_event" {
									fs.fs_eventHandler(incomingPacket)

									//push
								} else if incomingPacket.ContentType == "push" {
									fs.pushHandler(incomingPacket)

								} else if incomingPacket.ContentType == "pull" {
									fs.pullHandler(incomingPacket)
								}
							}
						} else {
							fmt.Println(error.Error())
						}
					}
				}
			}
			//if nothing on socket, sleep for half a second to save cpu
		} else {
			time.Sleep(500 * time.Millisecond)
		}
	}
}

func (fs *FileSession) pullHandler(incomingPacket packet.PacketStd) {

	if incomingPacket.Name == "REQ_FILELIST" {
		//db initializing
		db, error := sql.Open("sqlite3", "../gypo.db")

		//tells client pull request recieved
		newPacket := packet.PacketStd{packet.Packet{"pull", "REQ_FILELIST_RECV"}, ""}
		go newPacket.SendPacket(fs.Connection)

		//creates list of server files and sends back to client
		if error != nil {
			fmt.Println(error.Error())
		} else {
			//PacketList instance for server files(db)
			var server_fileList packet.PacketList

			//get number of files from db to use for file server_fileList.Data size
			var dbFileCount int
			error = db.QueryRow("SELECT count(*) AS number FROM files WHERE user_id = ?", fs.User.Id).Scan(&dbFileCount)

			if error != nil {
				fmt.Println(error.Error())
			} else {
				//sets PacketList instance variables
				server_fileList.Data = make([]packet.PacketStd, dbFileCount)
				server_fileList.ContentType = "pull"
				server_fileList.Name = "RESP_FILELIST"

				//get fileList from db
				rows, error := db.Query("SELECT filename, path, hash, is_dir FROM files WHERE user_id = ?", fs.User.Id)

				if error != nil {
					fmt.Println(error.Error())
				} else {
					var rowPacket packet.PacketStd
					var filename, path, hash string
					var is_dir int
					i := 0

					for rows.Next() {
						error = rows.Scan(&filename, &path, &hash, &is_dir)
						if error != nil {
							fmt.Println(error.Error())
						} else {
							if is_dir == 1 {
								rowPacket.ContentType = "folder"
								rowPacket.Name = path
								rowPacket.Data = ""
							} else {
								rowPacket.ContentType = "hash"
								rowPacket.Name = path + filename
								rowPacket.Data = hash
							}
						}
						server_fileList.Data[i] = rowPacket
						i++
					}
					go server_fileList.SendPacket(fs.Connection)
					fmt.Println("server_fileList size: ", len(server_fileList.Data))
				}
			}
		}
	} else if incomingPacket.Name == "REQ_FILE" {
		//wraps file in packet and sends it
		newPacket := packet.PacketStd{packet.Packet{"pull", "RESP_FILE"}, incomingPacket.Data}
		go newPacket.SendFilePacket(fs.Connection)
	}

}

func (fs *FileSession) pushHandler(incomingPacket packet.PacketStd) {

	fmt.Println("processing push")

	//getting pushList from socket
	incomingBytes, _ := strconv.Atoi(incomingPacket.Data)
	pushListB := make([]byte, incomingBytes)
	i := 0
	for i < incomingBytes {
		chunkSize, _ := fs.Connection.Read(pushListB[i:])
		i = i + chunkSize
		fmt.Println("read so far: ", i)
	}

	//unmarshal data from socket to PacketList instance
	var client_pushList packet.PacketList
	client_pushList.ContentType = "push"
	client_pushList.Name = "client"
	flsize, _ := strconv.Atoi(incomingPacket.Name)
	flObj := make([]packet.PacketStd, flsize)
	client_pushList.Data = flObj
	error := json.Unmarshal(pushListB, &client_pushList)

	if error == nil {
		fmt.Println("push recieved, " + incomingPacket.Name + " entries\n")
	} else {
		fmt.Println(error.Error())
	}

	//tells client push was recieved
	newPacket := packet.PacketStd{packet.Packet{"push", ""}, "PUSH_RECIEVED"}
	go newPacket.SendPacket(fs.Connection)

	//PacketList instance for server files(db)
	var server_fileList packet.PacketList

	db, error := sql.Open("sqlite3", "../gypo.db")

	if error != nil {
		fmt.Println(error.Error())
	} else {
		//get number of files from db to use for file array size
		var dbFileCount int
		error = db.QueryRow("SELECT count(*) AS number FROM files WHERE user_id = ?", fs.User.Id).Scan(&dbFileCount)

		if error != nil {
			fmt.Println(error.Error())
		} else {
			server_fileList.Data = make([]packet.PacketStd, dbFileCount)

			//fetches files from db and adds them to server_fileList
			rows, error := db.Query("SELECT filename, path, hash, is_dir FROM files WHERE user_id = ?", fs.User.Id)
			if error != nil {
				fmt.Println(error.Error())
			} else {
				var is_dir int
				var rowContentType, rowName, rowData string
				var rowPacket packet.PacketStd

				//populates server_fileList.Data
				i = 0
				for rows.Next() {
					error = rows.Scan(&rowContentType, &rowName, &rowData, &is_dir)
					//fmt.Println(i, " | ", is_dir)
					if error != nil {
						fmt.Println(error.Error())
					}
					if is_dir == 1 {
						rowPacket.ContentType = "folder"
						rowPacket.Name = rowName
						rowPacket.Data = ""
					} else {
						rowPacket.ContentType = "hash"
						rowPacket.Name = rowName + rowContentType
						rowPacket.Data = rowData
					}
					server_fileList.Data[i] = rowPacket
					i++
				}

				fmt.Println("server_fileList size: ", len(server_fileList.Data))
				fmt.Println("client_pushList size: ", len(client_pushList.Data))

				/*
				   i = 0
				   for i < len(server_fileList.Data) {
				       fmt.Println("ContentType: " + server_fileList.Data[i].ContentType + " | Name: " + server_fileList.Data[i].Name + " | Data: " + server_fileList.Data[i].Data)
				       i++
				   }

				   fmt.Println("\n\n\n\n")

				   i = 0
				   for i < len(client_pushList.Data) {
				       fmt.Println("ContentType: " + client_pushList.Data[i].ContentType + " | Name: " + client_pushList.Data[i].Name + " | Data: " + server_fileList.Data[i].Data)
				       i++
				   }*/

				//compares client_pushList to server_fileList
				nilPacket := packet.PacketStd{packet.Packet{"", ""}, ""} //to flag list entries as solved
//.........这里部分代码省略.........

func (fs *FileSession) fs_eventHandler(incomingPacket packet.PacketStd) {
	db, error := sql.Open("sqlite3", "../gypo.db")

	if error != nil {
		fmt.Println(error.Error())
	} else {

		//rename_file & rename_folder & move_file & move_folder
		if incomingPacket.Name == "rename_file" || incomingPacket.Name == "rename_folder" || incomingPacket.Name == "move_file" || incomingPacket.Name == "move_folder" {
			sourceDir := incomingPacket.Data[:strings.Index(incomingPacket.Data, "|")]
			destDir := incomingPacket.Data[len(sourceDir)+1:]

			//rename also moves, truncate errors as multiple moves in one directory will result in failed renames
			_ = os.Rename(sourceDir[1:], destDir[1:])

			//updates db
			if incomingPacket.Name == "rename_file" { //rename_file
				_, error := db.Exec("UPDATE files SET filename = ? WHERE filename = ? AND path = ? AND user_id = ?", destDir[strings.LastIndex(destDir, "/")+1:], sourceDir[strings.LastIndex(sourceDir, "/")+1:], sourceDir[:strings.LastIndex(sourceDir, "/")+1], fs.User.Id)
				if error != nil {
					fmt.Println(error.Error())
				}

			} else if incomingPacket.Name == "rename_folder" || incomingPacket.Name == "move_folder" { //rename_folder & move_folder
				_, error := db.Exec("UPDATE files SET path = ? WHERE path = ? AND user_id = ?", destDir, sourceDir, fs.User.Id)
				if error != nil {
					fmt.Println(error.Error())
				}

			} else if incomingPacket.Name == "move_file" { //move_file
				_, error := db.Exec("UPDATE files SET path = ? WHERE path = ? AND filename = ? AND user_id = ?", destDir[:strings.LastIndex(destDir, "/")+1], sourceDir[:strings.LastIndex(sourceDir, "/")+1], destDir[strings.LastIndex(destDir, "/")+1:], fs.User.Id)
				if error != nil {
					fmt.Println(error.Error())
				}
			}

			//create_folder
		} else if incomingPacket.Name == "create_folder" {
			//check if folder allready exist, if not make
			error = os.Chdir(incomingPacket.Data[1:])

			if error != nil {
				error = os.MkdirAll(incomingPacket.Data[1:], 07777) //liberal chmod

				if error != nil {
					fmt.Println(error.Error())

					//adds folder to db
				} else {
					_, error := db.Exec("INSERT INTO files (path, is_dir, user_id) VALUES (?, ?, ?)", incomingPacket.Data, 1, fs.User.Id)
					if error != nil {
						fmt.Println(error.Error())
					}
				}

			} else {
				//mave back to root
				_ = os.Chdir(fs.RootDir)
			}

			//delete_file
		} else if incomingPacket.Name == "delete_file" {
			error = os.Remove(fs.RootDir + incomingPacket.Data[1:])
			if error != nil {
				fmt.Println(error.Error())
			} else {
				//updates db
				_, error := db.Exec("DELETE FROM files WHERE filename = ? AND path = ? AND user_id = ?", incomingPacket.Data[strings.LastIndex(incomingPacket.Data, "/")+1:], incomingPacket.Data[:strings.LastIndex(incomingPacket.Data, "/")+1], fs.User.Id)
				if error != nil {
					fmt.Println(error.Error())
				}
			}

			//delete_folder
		} else if incomingPacket.Name == "delete_folder" {
			error = os.RemoveAll(fs.RootDir + incomingPacket.Data[1:])
			if error != nil {
				fmt.Println(error.Error())
			} else {
				//updates db
				_, error := db.Exec("DELETE FROM files WHERE path = ? AND user_id = ?", incomingPacket.Data, fs.User.Id)
				if error != nil {
					fmt.Println(error.Error())
				}
			}
		}

		//tells client fs_event done
		newPacket := packet.PacketStd{packet.Packet{"fs_event", ""}, "FS_EVENT_DONE"}
		go newPacket.SendPacket(fs.Connection)

		db.Close()
	}
}

func (fs *FileSession) fileHandler(incomingPacket packet.PacketStd) {

	var readBuffer [4096]byte

	//creates folders for file if nesecary
	if strings.LastIndex(incomingPacket.Name, "/") > 0 {
		error := os.MkdirAll(incomingPacket.Name[1:strings.LastIndex(incomingPacket.Name, "/")+1], 07777) //liberal chmod
		if error != nil {
			fmt.Println(error.Error())
		} else {
			error = os.Chdir(incomingPacket.Name[1 : strings.LastIndex(incomingPacket.Name, "/")+1])
			if error != nil {
				fmt.Println(error.Error())
			}
		}
	}

	//writes file
	file, _ := os.Create(incomingPacket.Name[strings.LastIndex(incomingPacket.Name, "/")+1:] + ".incomplete") //adds .incomplete extension during download
	i := 0
	incomingBytes, _ := strconv.Atoi(incomingPacket.Data)

	for i < incomingBytes {
		if (i + 4096) > incomingBytes {
			chunkSize, _ := fs.Connection.Read(readBuffer[:incomingBytes-i])
			_, _ = file.Write(readBuffer[:incomingBytes-i])
			i = i + chunkSize
			//fi, _ := file.Stat()
			//fmt.Println("ferdig", chunkSize , " recieved so far ", i, "/", incomingBytes, "written so far: ", fi.Size())

		} else {
			chunkSize, _ := fs.Connection.Read(readBuffer[:])
			_, _ = file.Write(readBuffer[:chunkSize])
			//fi, _ := file.Stat()
			i = i + chunkSize
			//fmt.Println("skriver", chunkSize, " recived so far ", i, "/", incomingBytes, "written so far: ", fi.Size())
		}
	}

	file.Close()
	//after all bytes are written file extension .incomplete is removed
	_ = os.Rename(incomingPacket.Name[strings.LastIndex(incomingPacket.Name, "/")+1:]+".incomplete", incomingPacket.Name[strings.LastIndex(incomingPacket.Name, "/")+1:])

	//moves back to root
	_ = os.Chdir(fs.RootDir)

	//adds/updates file hash from session to db
	db, error := sql.Open("sqlite3", "../gypo.db")

	if error != nil {
		fmt.Println(error.Error())
	} else {
		if fs.tempHash[incomingPacket.Name].Data[0:1] == "0" {
			_, error := db.Exec("INSERT INTO files (path, filename, hash, user_id) VALUES (?, ?, ?, ?)", incomingPacket.Name[:strings.LastIndex(incomingPacket.Name, "/")+1], incomingPacket.Name[strings.LastIndex(incomingPacket.Name, "/")+1:], fs.tempHash[incomingPacket.Name].Data[1:], fs.User.Id)
			if error != nil {
				fmt.Println(error.Error())
			} else {
				delete(fs.tempHash, incomingPacket.Name) //removes file from tempHash
			}
		} else {
			_, error := db.Exec("UPDATE files SET hash = ? WHERE path = ? AND filename = ? AND user_id = ?", fs.tempHash[incomingPacket.Name].Data[1:], incomingPacket.Name[:strings.LastIndex(incomingPacket.Name, "/")+1], incomingPacket.Name[strings.LastIndex(incomingPacket.Name, "/")+1:], fs.User.Id)
			if error != nil {
				fmt.Println(error.Error())
			} else {
				delete(fs.tempHash, incomingPacket.Name) //removes file from tempHash
			}
		}
		db.Close()
	}

	//tells client file has completed
	newPacket := packet.PacketStd{packet.Packet{"file", ""}, "SEND_FILE_DONE"}
	go newPacket.SendPacket(fs.Connection)
	fmt.Println(incomingPacket.Name[strings.LastIndex(incomingPacket.Name, "/")+1:], " - SEND_FILE_DONE\n\n")
}