gistfile0.txt

@nix { "action": "setPhase", "phase": "unpackPhase" }
Running phase: unpackPhase
unpacking source archive /nix/store/sz12dkhjzz0pb5pm6xadkdwzym6xnvbk-autobindings
source root is autobindings
@nix { "action": "setPhase", "phase": "patchPhase" }
Running phase: patchPhase
@nix { "action": "setPhase", "phase": "updateAutotoolsGnuConfigScriptsPhase" }
Running phase: updateAutotoolsGnuConfigScriptsPhase
@nix { "action": "setPhase", "phase": "configurePhase" }
Running phase: configurePhase
@nix { "action": "setPhase", "phase": "buildPhase" }
Running phase: buildPhase
make: which: No such file or directory
go run generate/generate_bindings.go --experiments ""serverExperiment""
generating app function for ActivatePeerEngine
generating app function for DeactivatePeerEngine
generating app function for ConfigureConnections
generating app function for CreateProfile
generating app function for LoadProfiles
generating app function for DeleteProfile
generating (json)app function for EnhancedImportProfile
generating profile function for ChangePassword
generating profile function for ExportProfile
generating (json)profile function for EnhancedImportBundle
generating profile function for ArchiveConversation
generating profile function for AcceptConversation
generating profile function for BlockConversation
generating profile function for UnblockConversation
generating profile function for DeleteConversation
generating profile function for PeerWithOnion
generating profile function for DisconnectFromPeer
generating (json-err)profile function for EnhancedGetConversationAccessControlList
generating profile function for EnhancedUpdateConversationAccessControlList
generating (json)profile function for SearchConversations
generating (json)profile function for EnhancedSendMessage
generating (json)profile function for EnhancedGetMessageById
generating (json)profile function for EnhancedGetMessageByContentHash
generating (json)profile function for EnhancedGetMessages
generating (json)profile function for EnhancedSendInviteMessage
generating profile function for UpdateMessageAttribute
generating profile function for StartGroup
generating profile function for QueueJoinServer
generating profile function for DisconnectFromServer
generating @profile-experiment function for PublishServerUpdate
generating @profile-experiment function for GetServerInfoList
generating @profile-experiment function for DeleteServerInfo
generating @profile-experiment function for DownloadFileDefaultLimit
generating @profile-experiment function for RestartFileShare
generating @profile-experiment function for StopFileShare
generating @profile-experiment function for CheckDownloadStatus
generating @profile-experiment function for VerifyOrResumeDownloadDefaultLimit
generating @(json)profile-experiment function for EnhancedShareFile
generating @(json)profile-experiment function for EnhancedGetSharedFiles
generating exp function for CreateServer
generating exp function for SetServerAttribute
generating exp function for LoadServers
generating exp function for LaunchServers
generating exp function for LaunchServer
generating exp function for StopServer
generating exp function for StopServers
generating exp function for DestroyServers
generating exp function for DeleteServer

//export c_ActivatePeerEngine
func c_ActivatePeerEngine(onion_ptr *C.char, onion_len C.int) {
	ActivatePeerEngine(C.GoStringN(onion_ptr, onion_len))
}

func ActivatePeerEngine(profile string) {
	application.ActivatePeerEngine(profile)
}

//export c_DeactivatePeerEngine
func c_DeactivatePeerEngine(onion_ptr *C.char, onion_len C.int) {
	DeactivatePeerEngine(C.GoStringN(onion_ptr, onion_len))
}

func DeactivatePeerEngine(profile string) {
	application.DeactivatePeerEngine(profile)
}

//export c_ConfigureConnections
func c_ConfigureConnections(onion_ptr *C.char, onion_len C.int,listen1 C.char,peers2 C.char,servers3 C.char) {
	ConfigureConnections(C.GoStringN(onion_ptr, onion_len),listen1 == 1,peers2 == 1,servers3 == 1)
}

func ConfigureConnections(profile string,listen1 bool,peers2 bool,servers3 bool) {
	application.ConfigureConnections(profile,listen1,peers2,servers3)
}

//export c_CreateProfile
func c_CreateProfile(name_ptr *C.char, name_len C.int,password_ptr *C.char, password_len C.int,autostart4 C.char) {
	CreateProfile(C.GoStringN(name_ptr, name_len),C.GoStringN(password_ptr, password_len),autostart4 == 1)
}

func CreateProfile(name string,password string,autostart4 bool) {
	application.CreateProfile(name,password,autostart4)
}

//export c_LoadProfiles
func c_LoadProfiles(password_ptr *C.char, password_len C.int) {
	LoadProfiles(C.GoStringN(password_ptr, password_len))
}

func LoadProfiles(password string) {
	application.LoadProfiles(password)
}

//export c_DeleteProfile
func c_DeleteProfile(onion_ptr *C.char, onion_len C.int,password_ptr *C.char, password_len C.int) {
	DeleteProfile(C.GoStringN(onion_ptr, onion_len),C.GoStringN(password_ptr, password_len))
}

func DeleteProfile(profile string,password string) {
	application.DeleteProfile(profile,password)
}

//export c_ImportProfile
func c_ImportProfile(file5_ptr *C.char, file5_len C.int,password_ptr *C.char, password_len C.int) *C.char  {
	return C.CString(ImportProfile(C.GoStringN(file5_ptr, file5_len),C.GoStringN(password_ptr, password_len)))
}

func ImportProfile(file5 string,password string) string {
	return application.EnhancedImportProfile(file5,password)
}

//export c_ChangePassword
func c_ChangePassword(onion_ptr *C.char, onion_len C.int,current6_ptr *C.char, current6_len C.int,newPassword7_ptr *C.char, newPassword7_len C.int,newPasswordAgain8_ptr *C.char, newPasswordAgain8_len C.int) {
	ChangePassword(C.GoStringN(onion_ptr, onion_len),C.GoStringN(current6_ptr, current6_len),C.GoStringN(newPassword7_ptr, newPassword7_len),C.GoStringN(newPasswordAgain8_ptr, newPasswordAgain8_len))
}

func ChangePassword(profile string,current6 string,newPassword7 string,newPasswordAgain8 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.ChangePassword(current6,newPassword7,newPasswordAgain8)
	}
}

//export c_ExportProfile
func c_ExportProfile(onion_ptr *C.char, onion_len C.int,file9_ptr *C.char, file9_len C.int) {
	ExportProfile(C.GoStringN(onion_ptr, onion_len),C.GoStringN(file9_ptr, file9_len))
}

func ExportProfile(profile string,file9 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.ExportProfile(file9)
	}
}

//export c_ImportBundle
func c_ImportBundle(onion_ptr *C.char, onion_len C.int,bundle10_ptr *C.char, bundle10_len C.int)  *C.char {
	return C.CString(ImportBundle(C.GoStringN(onion_ptr, onion_len),C.GoStringN(bundle10_ptr, bundle10_len)))
}

func ImportBundle(profile string,bundle10 string) string {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
				return cwtchProfile.EnhancedImportBundle(bundle10)
	}
	return ""
}

//export c_ArchiveConversation
func c_ArchiveConversation(onion_ptr *C.char, onion_len C.int,conversation C.int) {
	ArchiveConversation(C.GoStringN(onion_ptr, onion_len),int(conversation))
}

func ArchiveConversation(profile string,conversation int) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.ArchiveConversation(conversation)
	}
}

//export c_AcceptConversation
func c_AcceptConversation(onion_ptr *C.char, onion_len C.int,conversation C.int) {
	AcceptConversation(C.GoStringN(onion_ptr, onion_len),int(conversation))
}

func AcceptConversation(profile string,conversation int) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.AcceptConversation(conversation)
	}
}

//export c_BlockConversation
func c_BlockConversation(onion_ptr *C.char, onion_len C.int,conversation C.int) {
	BlockConversation(C.GoStringN(onion_ptr, onion_len),int(conversation))
}

func BlockConversation(profile string,conversation int) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.BlockConversation(conversation)
	}
}

//export c_UnblockConversation
func c_UnblockConversation(onion_ptr *C.char, onion_len C.int,conversation C.int) {
	UnblockConversation(C.GoStringN(onion_ptr, onion_len),int(conversation))
}

func UnblockConversation(profile string,conversation int) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.UnblockConversation(conversation)
	}
}

//export c_DeleteConversation
func c_DeleteConversation(onion_ptr *C.char, onion_len C.int,conversation C.int) {
	DeleteConversation(C.GoStringN(onion_ptr, onion_len),int(conversation))
}

func DeleteConversation(profile string,conversation int) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.DeleteConversation(conversation)
	}
}

//export c_PeerWithOnion
func c_PeerWithOnion(onion_ptr *C.char, onion_len C.int,handle11_ptr *C.char, handle11_len C.int) {
	PeerWithOnion(C.GoStringN(onion_ptr, onion_len),C.GoStringN(handle11_ptr, handle11_len))
}

func PeerWithOnion(profile string,handle11 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.PeerWithOnion(handle11)
	}
}

//export c_DisconnectFromPeer
func c_DisconnectFromPeer(onion_ptr *C.char, onion_len C.int,handle12_ptr *C.char, handle12_len C.int) {
	DisconnectFromPeer(C.GoStringN(onion_ptr, onion_len),C.GoStringN(handle12_ptr, handle12_len))
}

func DisconnectFromPeer(profile string,handle12 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.DisconnectFromPeer(handle12)
	}
}

//export c_GetConversationAccessControlList
func c_GetConversationAccessControlList(onion_ptr *C.char, onion_len C.int,conversation C.int)  *C.char {
	return C.CString(GetConversationAccessControlList(C.GoStringN(onion_ptr, onion_len),int(conversation)))
}

func GetConversationAccessControlList(profile string,conversation int) string {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
				res,err :=  cwtchProfile.EnhancedGetConversationAccessControlList(conversation)
													if err != nil {
															log.Errorf("could not GetConversationAccessControlList %v", err)
													}
												 return res
	}
	return ""
}

//export c_UpdateConversationAccessControlList
func c_UpdateConversationAccessControlList(onion_ptr *C.char, onion_len C.int,conversation C.int,json13_ptr *C.char, json13_len C.int) {
	UpdateConversationAccessControlList(C.GoStringN(onion_ptr, onion_len),int(conversation),C.GoStringN(json13_ptr, json13_len))
}

func UpdateConversationAccessControlList(profile string,conversation int,json13 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.EnhancedUpdateConversationAccessControlList(conversation,json13)
	}
}

//export c_SearchConversations
func c_SearchConversations(onion_ptr *C.char, onion_len C.int,pattern14_ptr *C.char, pattern14_len C.int)  *C.char {
	return C.CString(SearchConversations(C.GoStringN(onion_ptr, onion_len),C.GoStringN(pattern14_ptr, pattern14_len)))
}

func SearchConversations(profile string,pattern14 string) string {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
				return cwtchProfile.SearchConversations(pattern14)
	}
	return ""
}

//export c_SendMessage
func c_SendMessage(onion_ptr *C.char, onion_len C.int,conversation C.int,msg15_ptr *C.char, msg15_len C.int)  *C.char {
	return C.CString(SendMessage(C.GoStringN(onion_ptr, onion_len),int(conversation),C.GoStringN(msg15_ptr, msg15_len)))
}

func SendMessage(profile string,conversation int,msg15 string) string {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
				return cwtchProfile.EnhancedSendMessage(conversation,msg15)
	}
	return ""
}

//export c_GetMessageById
func c_GetMessageById(onion_ptr *C.char, onion_len C.int,conversation C.int,message_id C.int)  *C.char {
	return C.CString(GetMessageById(C.GoStringN(onion_ptr, onion_len),int(conversation),int(message_id)))
}

func GetMessageById(profile string,conversation int,message_id int) string {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
				return cwtchProfile.EnhancedGetMessageById(conversation,message_id)
	}
	return ""
}

//export c_GetMessageByContentHash
func c_GetMessageByContentHash(onion_ptr *C.char, onion_len C.int,conversation C.int,contentHash16_ptr *C.char, contentHash16_len C.int)  *C.char {
	return C.CString(GetMessageByContentHash(C.GoStringN(onion_ptr, onion_len),int(conversation),C.GoStringN(contentHash16_ptr, contentHash16_len)))
}

func GetMessageByContentHash(profile string,conversation int,contentHash16 string) string {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
				return cwtchProfile.EnhancedGetMessageByContentHash(conversation,contentHash16)
	}
	return ""
}

//export c_GetMessages
func c_GetMessages(onion_ptr *C.char, onion_len C.int,conversation C.int,index C.int,count C.uint)  *C.char {
	return C.CString(GetMessages(C.GoStringN(onion_ptr, onion_len),int(conversation),int(index),int(count)))
}

func GetMessages(profile string,conversation int,index int,count int) string {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
				return cwtchProfile.EnhancedGetMessages(conversation,index,uint(count))
	}
	return ""
}

//export c_SendInviteMessage
func c_SendInviteMessage(onion_ptr *C.char, onion_len C.int,conversation C.int,target C.int)  *C.char {
	return C.CString(SendInviteMessage(C.GoStringN(onion_ptr, onion_len),int(conversation),int(target)))
}

func SendInviteMessage(profile string,conversation int,target int) string {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
				return cwtchProfile.EnhancedSendInviteMessage(conversation,target)
	}
	return ""
}

//export c_UpdateMessageAttribute
func c_UpdateMessageAttribute(onion_ptr *C.char, onion_len C.int,conversation C.int,channel_id C.int,message_id C.int,attributeKey17_ptr *C.char, attributeKey17_len C.int,attributeValue18_ptr *C.char, attributeValue18_len C.int) {
	UpdateMessageAttribute(C.GoStringN(onion_ptr, onion_len),int(conversation),int(channel_id),int(message_id),C.GoStringN(attributeKey17_ptr, attributeKey17_len),C.GoStringN(attributeValue18_ptr, attributeValue18_len))
}

func UpdateMessageAttribute(profile string,conversation int,channel_id int,message_id int,attributeKey17 string,attributeValue18 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.UpdateMessageAttribute(conversation,channel_id,message_id,attributeKey17,attributeValue18)
	}
}

//export c_StartGroup
func c_StartGroup(onion_ptr *C.char, onion_len C.int,name19_ptr *C.char, name19_len C.int,server20_ptr *C.char, server20_len C.int) {
	StartGroup(C.GoStringN(onion_ptr, onion_len),C.GoStringN(name19_ptr, name19_len),C.GoStringN(server20_ptr, server20_len))
}

func StartGroup(profile string,name19 string,server20 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.StartGroup(name19,server20)
	}
}

//export c_QueueJoinServer
func c_QueueJoinServer(onion_ptr *C.char, onion_len C.int,handle21_ptr *C.char, handle21_len C.int) {
	QueueJoinServer(C.GoStringN(onion_ptr, onion_len),C.GoStringN(handle21_ptr, handle21_len))
}

func QueueJoinServer(profile string,handle21 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.QueueJoinServer(handle21)
	}
}

//export c_DisconnectFromServer
func c_DisconnectFromServer(onion_ptr *C.char, onion_len C.int,handle22_ptr *C.char, handle22_len C.int) {
	DisconnectFromServer(C.GoStringN(onion_ptr, onion_len),C.GoStringN(handle22_ptr, handle22_len))
}

func DisconnectFromServer(profile string,handle22 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		cwtchProfile.DisconnectFromServer(handle22)
	}
}

//export c_PublishServerUpdate
func c_PublishServerUpdate(onion_ptr *C.char, onion_len C.int,) {
	PublishServerUpdate(C.GoStringN(onion_ptr, onion_len),)
}

func PublishServerUpdate(profile string,) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		functionality := servers.FunctionalityGate()
		if functionality != nil {
			err := functionality.PublishServerUpdate(cwtchProfile, )
			if err != nil {
				log.Errorf("error calling experimental feature PublishServerUpdate: %v", err)
			}
		}
	}
}

//export c_GetServerInfoList
func c_GetServerInfoList(onion_ptr *C.char, onion_len C.int,) {
	GetServerInfoList(C.GoStringN(onion_ptr, onion_len),)
}

func GetServerInfoList(profile string,) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		functionality := servers.FunctionalityGate()
		if functionality != nil {
			err := functionality.GetServerInfoList(cwtchProfile, )
			if err != nil {
				log.Errorf("error calling experimental feature GetServerInfoList: %v", err)
			}
		}
	}
}

//export c_DeleteServerInfo
func c_DeleteServerInfo(onion_ptr *C.char, onion_len C.int,serverOnion23_ptr *C.char, serverOnion23_len C.int) {
	DeleteServerInfo(C.GoStringN(onion_ptr, onion_len),C.GoStringN(serverOnion23_ptr, serverOnion23_len))
}

func DeleteServerInfo(profile string,serverOnion23 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		functionality := servers.FunctionalityGate()
		if functionality != nil {
			err := functionality.DeleteServerInfo(cwtchProfile, serverOnion23)
			if err != nil {
				log.Errorf("error calling experimental feature DeleteServerInfo: %v", err)
			}
		}
	}
}

//export c_DownloadFileDefaultLimit
func c_DownloadFileDefaultLimit(onion_ptr *C.char, onion_len C.int,conversation C.int,filepath24_ptr *C.char, filepath24_len C.int,manifest25_ptr *C.char, manifest25_len C.int,filekey26_ptr *C.char, filekey26_len C.int) {
	DownloadFileDefaultLimit(C.GoStringN(onion_ptr, onion_len),int(conversation),C.GoStringN(filepath24_ptr, filepath24_len),C.GoStringN(manifest25_ptr, manifest25_len),C.GoStringN(filekey26_ptr, filekey26_len))
}

func DownloadFileDefaultLimit(profile string,conversation int,filepath24 string,manifest25 string,filekey26 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		functionality := filesharing.FunctionalityGate()
		if functionality != nil {
			err := functionality.DownloadFileDefaultLimit(cwtchProfile, conversation,filepath24,manifest25,filekey26)
			if err != nil {
				log.Errorf("error calling experimental feature DownloadFileDefaultLimit: %v", err)
			}
		}
	}
}

//export c_RestartFileShare
func c_RestartFileShare(onion_ptr *C.char, onion_len C.int,filekey27_ptr *C.char, filekey27_len C.int) {
	RestartFileShare(C.GoStringN(onion_ptr, onion_len),C.GoStringN(filekey27_ptr, filekey27_len))
}

func RestartFileShare(profile string,filekey27 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		functionality := filesharing.FunctionalityGate()
		if functionality != nil {
			err := functionality.RestartFileShare(cwtchProfile, filekey27)
			if err != nil {
				log.Errorf("error calling experimental feature RestartFileShare: %v", err)
			}
		}
	}
}

//export c_StopFileShare
func c_StopFileShare(onion_ptr *C.char, onion_len C.int,filekey28_ptr *C.char, filekey28_len C.int) {
	StopFileShare(C.GoStringN(onion_ptr, onion_len),C.GoStringN(filekey28_ptr, filekey28_len))
}

func StopFileShare(profile string,filekey28 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		functionality := filesharing.FunctionalityGate()
		if functionality != nil {
			err := functionality.StopFileShare(cwtchProfile, filekey28)
			if err != nil {
				log.Errorf("error calling experimental feature StopFileShare: %v", err)
			}
		}
	}
}

//export c_CheckDownloadStatus
func c_CheckDownloadStatus(onion_ptr *C.char, onion_len C.int,filekey29_ptr *C.char, filekey29_len C.int) {
	CheckDownloadStatus(C.GoStringN(onion_ptr, onion_len),C.GoStringN(filekey29_ptr, filekey29_len))
}

func CheckDownloadStatus(profile string,filekey29 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		functionality := filesharing.FunctionalityGate()
		if functionality != nil {
			err := functionality.CheckDownloadStatus(cwtchProfile, filekey29)
			if err != nil {
				log.Errorf("error calling experimental feature CheckDownloadStatus: %v", err)
			}
		}
	}
}

//export c_VerifyOrResumeDownloadDefaultLimit
func c_VerifyOrResumeDownloadDefaultLimit(onion_ptr *C.char, onion_len C.int,conversation C.int,filekey30_ptr *C.char, filekey30_len C.int) {
	VerifyOrResumeDownloadDefaultLimit(C.GoStringN(onion_ptr, onion_len),int(conversation),C.GoStringN(filekey30_ptr, filekey30_len))
}

func VerifyOrResumeDownloadDefaultLimit(profile string,conversation int,filekey30 string) {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		functionality := filesharing.FunctionalityGate()
		if functionality != nil {
			err := functionality.VerifyOrResumeDownloadDefaultLimit(cwtchProfile, conversation,filekey30)
			if err != nil {
				log.Errorf("error calling experimental feature VerifyOrResumeDownloadDefaultLimit: %v", err)
			}
		}
	}
}

//export c_ShareFile
func c_ShareFile(onion_ptr *C.char, onion_len C.int,conversation C.int,filepath31_ptr *C.char, filepath31_len C.int)  *C.char  {
	return C.CString(ShareFile(C.GoStringN(onion_ptr, onion_len),int(conversation),C.GoStringN(filepath31_ptr, filepath31_len)))
}

func ShareFile(profile string,conversation int,filepath31 string) string {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		functionality := filesharing.FunctionalityGate()
		if functionality != nil {
			return functionality.EnhancedShareFile(cwtchProfile, conversation,filepath31)
		}
	}
	return ""
}

//export c_GetSharedFiles
func c_GetSharedFiles(onion_ptr *C.char, onion_len C.int,conversation C.int)  *C.char  {
	return C.CString(GetSharedFiles(C.GoStringN(onion_ptr, onion_len),int(conversation)))
}

func GetSharedFiles(profile string,conversation int) string {
	cwtchProfile := application.GetPeer(profile)
	if cwtchProfile != nil {
		functionality := filesharing.FunctionalityGate()
		if functionality != nil {
			return functionality.EnhancedGetSharedFiles(cwtchProfile, conversation)
		}
	}
	return ""
}
var serverExperiment *server_hosting.ServersFunctionality

//export c_CreateServer
func c_CreateServer(password_ptr *C.char, password_len C.int,description32_ptr *C.char, description32_len C.int,autostart33 C.char) {
	CreateServer(C.GoStringN(password_ptr, password_len),C.GoStringN(description32_ptr, description32_len),autostart33 == 1)
}

func CreateServer(password string,description32 string,autostart33 bool) {
	serverExperiment.CreateServer(application,password,description32,autostart33)
}

//export c_SetServerAttribute
func c_SetServerAttribute(handle34_ptr *C.char, handle34_len C.int,key35_ptr *C.char, key35_len C.int,val36_ptr *C.char, val36_len C.int) {
	SetServerAttribute(C.GoStringN(handle34_ptr, handle34_len),C.GoStringN(key35_ptr, key35_len),C.GoStringN(val36_ptr, val36_len))
}

func SetServerAttribute(handle34 string,key35 string,val36 string) {
	serverExperiment.SetServerAttribute(application,handle34,key35,val36)
}

//export c_LoadServers
func c_LoadServers(password_ptr *C.char, password_len C.int) {
	LoadServers(C.GoStringN(password_ptr, password_len))
}

func LoadServers(password string) {
	serverExperiment.LoadServers(application,&globalACN,password)
}

//export c_LaunchServers
func c_LaunchServers() {
	LaunchServers()
}

func LaunchServers() {
	serverExperiment.LaunchServers(application,&globalACN)
}

//export c_LaunchServer
func c_LaunchServer(handle37_ptr *C.char, handle37_len C.int) {
	LaunchServer(C.GoStringN(handle37_ptr, handle37_len))
}

func LaunchServer(handle37 string) {
	serverExperiment.LaunchServer(application,handle37)
}

//export c_StopServer
func c_StopServer(handle38_ptr *C.char, handle38_len C.int) {
	StopServer(C.GoStringN(handle38_ptr, handle38_len))
}

func StopServer(handle38 string) {
	serverExperiment.StopServer(application,handle38)
}

//export c_StopServers
func c_StopServers() {
	StopServers()
}

func StopServers() {
	serverExperiment.StopServers(application)
}

//export c_DestroyServers
func c_DestroyServers() {
	DestroyServers()
}

func DestroyServers() {
	serverExperiment.DestroyServers()
}

//export c_DeleteServer
func c_DeleteServer(handle39_ptr *C.char, handle39_len C.int,password_ptr *C.char, password_len C.int) {
	DeleteServer(C.GoStringN(handle39_ptr, handle39_len),C.GoStringN(password_ptr, password_len))
}

func DeleteServer(handle39 string,password string) {
	serverExperiment.DeleteServer(application,handle39,password)
}

./switch-ffi.sh
go build -trimpath -ldflags "-buildid=autobindings-v0.0.14 -X main.buildVer=autobindings-v0.0.14 -X main.buildDate=2024-02-27-02:07" -buildmode c-shared -o libCwtch.so
lib.go:31:2: cannot find module providing package github.com/mutecomm/go-sqlcipher/v4: import lookup disabled by -mod=vendor
make: *** [Makefile:38: libCwtch.so] Error 1