slidge-whatsapp 0.2.2__cp313-cp313-manylinux_2_36_aarch64.whl → 0.2.5__cp313-cp313-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/download.go

@@ -0,0 +1,370 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package whatsmeow
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+	"time"
+
+	"go.mau.fi/util/retryafter"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protoreflect"
+
+	"go.mau.fi/whatsmeow/proto/waE2E"
+	"go.mau.fi/whatsmeow/proto/waHistorySync"
+	"go.mau.fi/whatsmeow/proto/waMediaTransport"
+	"go.mau.fi/whatsmeow/proto/waServerSync"
+	"go.mau.fi/whatsmeow/socket"
+	"go.mau.fi/whatsmeow/util/cbcutil"
+	"go.mau.fi/whatsmeow/util/hkdfutil"
+)
+
+// MediaType represents a type of uploaded file on WhatsApp.
+// The value is the key which is used as a part of generating the encryption keys.
+type MediaType string
+
+// The known media types
+const (
+	MediaImage    MediaType = "WhatsApp Image Keys"
+	MediaVideo    MediaType = "WhatsApp Video Keys"
+	MediaAudio    MediaType = "WhatsApp Audio Keys"
+	MediaDocument MediaType = "WhatsApp Document Keys"
+	MediaHistory  MediaType = "WhatsApp History Keys"
+	MediaAppState MediaType = "WhatsApp App State Keys"
+
+	MediaLinkThumbnail MediaType = "WhatsApp Link Thumbnail Keys"
+)
+
+// DownloadableMessage represents a protobuf message that contains attachment info.
+//
+// All of the downloadable messages inside a Message struct implement this interface
+// (ImageMessage, VideoMessage, AudioMessage, DocumentMessage, StickerMessage).
+type DownloadableMessage interface {
+	GetDirectPath() string
+	GetMediaKey() []byte
+	GetFileSHA256() []byte
+	GetFileEncSHA256() []byte
+}
+
+type MediaTypeable interface {
+	GetMediaType() MediaType
+}
+
+// DownloadableThumbnail represents a protobuf message that contains a thumbnail attachment.
+//
+// This is primarily meant for link preview thumbnails in ExtendedTextMessage.
+type DownloadableThumbnail interface {
+	proto.Message
+	GetThumbnailDirectPath() string
+	GetThumbnailSHA256() []byte
+	GetThumbnailEncSHA256() []byte
+	GetMediaKey() []byte
+}
+
+// All the message types that are intended to be downloadable
+var (
+	_ DownloadableMessage   = (*waE2E.ImageMessage)(nil)
+	_ DownloadableMessage   = (*waE2E.AudioMessage)(nil)
+	_ DownloadableMessage   = (*waE2E.VideoMessage)(nil)
+	_ DownloadableMessage   = (*waE2E.DocumentMessage)(nil)
+	_ DownloadableMessage   = (*waE2E.StickerMessage)(nil)
+	_ DownloadableMessage   = (*waHistorySync.StickerMetadata)(nil)
+	_ DownloadableMessage   = (*waE2E.HistorySyncNotification)(nil)
+	_ DownloadableMessage   = (*waServerSync.ExternalBlobReference)(nil)
+	_ DownloadableThumbnail = (*waE2E.ExtendedTextMessage)(nil)
+)
+
+type downloadableMessageWithLength interface {
+	DownloadableMessage
+	GetFileLength() uint64
+}
+
+type downloadableMessageWithSizeBytes interface {
+	DownloadableMessage
+	GetFileSizeBytes() uint64
+}
+
+type downloadableMessageWithURL interface {
+	DownloadableMessage
+	GetURL() string
+}
+
+var classToMediaType = map[protoreflect.Name]MediaType{
+	"ImageMessage":    MediaImage,
+	"AudioMessage":    MediaAudio,
+	"VideoMessage":    MediaVideo,
+	"DocumentMessage": MediaDocument,
+	"StickerMessage":  MediaImage,
+	"StickerMetadata": MediaImage,
+
+	"HistorySyncNotification": MediaHistory,
+	"ExternalBlobReference":   MediaAppState,
+}
+
+var classToThumbnailMediaType = map[protoreflect.Name]MediaType{
+	"ExtendedTextMessage": MediaLinkThumbnail,
+}
+
+var mediaTypeToMMSType = map[MediaType]string{
+	MediaImage:    "image",
+	MediaAudio:    "audio",
+	MediaVideo:    "video",
+	MediaDocument: "document",
+	MediaHistory:  "md-msg-hist",
+	MediaAppState: "md-app-state",
+
+	MediaLinkThumbnail: "thumbnail-link",
+}
+
+// DownloadAny loops through the downloadable parts of the given message and downloads the first non-nil item.
+func (cli *Client) DownloadAny(msg *waE2E.Message) (data []byte, err error) {
+	if msg == nil {
+		return nil, ErrNothingDownloadableFound
+	}
+	switch {
+	case msg.ImageMessage != nil:
+		return cli.Download(msg.ImageMessage)
+	case msg.VideoMessage != nil:
+		return cli.Download(msg.VideoMessage)
+	case msg.AudioMessage != nil:
+		return cli.Download(msg.AudioMessage)
+	case msg.DocumentMessage != nil:
+		return cli.Download(msg.DocumentMessage)
+	case msg.StickerMessage != nil:
+		return cli.Download(msg.StickerMessage)
+	default:
+		return nil, ErrNothingDownloadableFound
+	}
+}
+
+func getSize(msg DownloadableMessage) int {
+	switch sized := msg.(type) {
+	case downloadableMessageWithLength:
+		return int(sized.GetFileLength())
+	case downloadableMessageWithSizeBytes:
+		return int(sized.GetFileSizeBytes())
+	default:
+		return -1
+	}
+}
+
+// DownloadThumbnail downloads a thumbnail from a message.
+//
+// This is primarily intended for downloading link preview thumbnails, which are in ExtendedTextMessage:
+//
+//	var msg *waE2E.Message
+//	...
+//	thumbnailImageBytes, err := cli.DownloadThumbnail(msg.GetExtendedTextMessage())
+func (cli *Client) DownloadThumbnail(msg DownloadableThumbnail) ([]byte, error) {
+	mediaType, ok := classToThumbnailMediaType[msg.ProtoReflect().Descriptor().Name()]
+	if !ok {
+		return nil, fmt.Errorf("%w '%s'", ErrUnknownMediaType, string(msg.ProtoReflect().Descriptor().Name()))
+	} else if len(msg.GetThumbnailDirectPath()) > 0 {
+		return cli.DownloadMediaWithPath(msg.GetThumbnailDirectPath(), msg.GetThumbnailEncSHA256(), msg.GetThumbnailSHA256(), msg.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType])
+	} else {
+		return nil, ErrNoURLPresent
+	}
+}
+
+// GetMediaType returns the MediaType value corresponding to the given protobuf message.
+func GetMediaType(msg DownloadableMessage) MediaType {
+	protoReflecter, ok := msg.(proto.Message)
+	if !ok {
+		mediaTypeable, ok := msg.(MediaTypeable)
+		if !ok {
+			return ""
+		}
+		return mediaTypeable.GetMediaType()
+	}
+	return classToMediaType[protoReflecter.ProtoReflect().Descriptor().Name()]
+}
+
+// Download downloads the attachment from the given protobuf message.
+//
+// The attachment is a specific part of a Message protobuf struct, not the message itself, e.g.
+//
+//	var msg *waE2E.Message
+//	...
+//	imageData, err := cli.Download(msg.GetImageMessage())
+//
+// You can also use DownloadAny to download the first non-nil sub-message.
+func (cli *Client) Download(msg DownloadableMessage) ([]byte, error) {
+	if cli == nil {
+		return nil, ErrClientIsNil
+	}
+	mediaType := GetMediaType(msg)
+	if mediaType == "" {
+		return nil, fmt.Errorf("%w %T", ErrUnknownMediaType, msg)
+	}
+	urlable, ok := msg.(downloadableMessageWithURL)
+	var url string
+	var isWebWhatsappNetURL bool
+	if ok {
+		url = urlable.GetURL()
+		isWebWhatsappNetURL = strings.HasPrefix(url, "https://web.whatsapp.net")
+	}
+	if len(url) > 0 && !isWebWhatsappNetURL {
+		return cli.downloadAndDecrypt(url, msg.GetMediaKey(), mediaType, getSize(msg), msg.GetFileEncSHA256(), msg.GetFileSHA256())
+	} else if len(msg.GetDirectPath()) > 0 {
+		return cli.DownloadMediaWithPath(msg.GetDirectPath(), msg.GetFileEncSHA256(), msg.GetFileSHA256(), msg.GetMediaKey(), getSize(msg), mediaType, mediaTypeToMMSType[mediaType])
+	} else {
+		if isWebWhatsappNetURL {
+			cli.Log.Warnf("Got a media message with a web.whatsapp.net URL (%s) and no direct path", url)
+		}
+		return nil, ErrNoURLPresent
+	}
+}
+
+func (cli *Client) DownloadFB(transport *waMediaTransport.WAMediaTransport_Integral, mediaType MediaType) ([]byte, error) {
+	return cli.DownloadMediaWithPath(transport.GetDirectPath(), transport.GetFileEncSHA256(), transport.GetFileSHA256(), transport.GetMediaKey(), -1, mediaType, mediaTypeToMMSType[mediaType])
+}
+
+// DownloadMediaWithPath downloads an attachment by manually specifying the path and encryption details.
+func (cli *Client) DownloadMediaWithPath(directPath string, encFileHash, fileHash, mediaKey []byte, fileLength int, mediaType MediaType, mmsType string) (data []byte, err error) {
+	var mediaConn *MediaConn
+	mediaConn, err = cli.refreshMediaConn(false)
+	if err != nil {
+		return nil, fmt.Errorf("failed to refresh media connections: %w", err)
+	}
+	if len(mmsType) == 0 {
+		mmsType = mediaTypeToMMSType[mediaType]
+	}
+	for i, host := range mediaConn.Hosts {
+		// TODO omit hash for unencrypted media?
+		mediaURL := fmt.Sprintf("https://%s%s&hash=%s&mms-type=%s&__wa-mms=", host.Hostname, directPath, base64.URLEncoding.EncodeToString(encFileHash), mmsType)
+		data, err = cli.downloadAndDecrypt(mediaURL, mediaKey, mediaType, fileLength, encFileHash, fileHash)
+		if err == nil || errors.Is(err, ErrFileLengthMismatch) || errors.Is(err, ErrInvalidMediaSHA256) ||
+			errors.Is(err, ErrMediaDownloadFailedWith403) || errors.Is(err, ErrMediaDownloadFailedWith404) || errors.Is(err, ErrMediaDownloadFailedWith410) {
+			return
+		} else if i >= len(mediaConn.Hosts)-1 {
+			return nil, fmt.Errorf("failed to download media from last host: %w", err)
+		}
+		cli.Log.Warnf("Failed to download media: %s, trying with next host...", err)
+	}
+	return
+}
+
+func (cli *Client) downloadAndDecrypt(url string, mediaKey []byte, appInfo MediaType, fileLength int, fileEncSHA256, fileSHA256 []byte) (data []byte, err error) {
+	iv, cipherKey, macKey, _ := getMediaKeys(mediaKey, appInfo)
+	var ciphertext, mac []byte
+	if ciphertext, mac, err = cli.downloadPossiblyEncryptedMediaWithRetries(url, fileEncSHA256); err != nil {
+
+	} else if mediaKey == nil && fileEncSHA256 == nil && mac == nil {
+		// Unencrypted media, just return the downloaded data
+		data = ciphertext
+	} else if err = validateMedia(iv, ciphertext, macKey, mac); err != nil {
+
+	} else if data, err = cbcutil.Decrypt(cipherKey, iv, ciphertext); err != nil {
+		err = fmt.Errorf("failed to decrypt file: %w", err)
+	} else if fileLength >= 0 && len(data) != fileLength {
+		err = fmt.Errorf("%w: expected %d, got %d", ErrFileLengthMismatch, fileLength, len(data))
+	} else if len(fileSHA256) == 32 && sha256.Sum256(data) != *(*[32]byte)(fileSHA256) {
+		err = ErrInvalidMediaSHA256
+	}
+	return
+}
+
+func getMediaKeys(mediaKey []byte, appInfo MediaType) (iv, cipherKey, macKey, refKey []byte) {
+	mediaKeyExpanded := hkdfutil.SHA256(mediaKey, nil, []byte(appInfo), 112)
+	return mediaKeyExpanded[:16], mediaKeyExpanded[16:48], mediaKeyExpanded[48:80], mediaKeyExpanded[80:]
+}
+
+func shouldRetryMediaDownload(err error) bool {
+	var netErr net.Error
+	var httpErr DownloadHTTPError
+	return errors.As(err, &netErr) ||
+		strings.HasPrefix(err.Error(), "stream error:") || // hacky check for http2 errors
+		(errors.As(err, &httpErr) && retryafter.Should(httpErr.StatusCode, true))
+}
+
+func (cli *Client) downloadPossiblyEncryptedMediaWithRetries(url string, checksum []byte) (file, mac []byte, err error) {
+	for retryNum := 0; retryNum < 5; retryNum++ {
+		if checksum == nil {
+			file, err = cli.downloadMedia(url)
+		} else {
+			file, mac, err = cli.downloadEncryptedMedia(url, checksum)
+		}
+		if err == nil || !shouldRetryMediaDownload(err) {
+			return
+		}
+		retryDuration := time.Duration(retryNum+1) * time.Second
+		var httpErr DownloadHTTPError
+		if errors.As(err, &httpErr) {
+			retryDuration = retryafter.Parse(httpErr.Response.Header.Get("Retry-After"), retryDuration)
+		}
+		cli.Log.Warnf("Failed to download media due to network error: %v, retrying in %s...", err, retryDuration)
+		time.Sleep(retryDuration)
+	}
+	return
+}
+
+func (cli *Client) doMediaDownloadRequest(url string) (*http.Response, error) {
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to prepare request: %w", err)
+	}
+	req.Header.Set("Origin", socket.Origin)
+	req.Header.Set("Referer", socket.Origin+"/")
+	if cli.MessengerConfig != nil {
+		req.Header.Set("User-Agent", cli.MessengerConfig.UserAgent)
+	}
+	// TODO user agent for whatsapp downloads?
+	resp, err := cli.http.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		_ = resp.Body.Close()
+		return nil, DownloadHTTPError{Response: resp}
+	}
+	return resp, nil
+}
+
+func (cli *Client) downloadMedia(url string) ([]byte, error) {
+	resp, err := cli.doMediaDownloadRequest(url)
+	if err != nil {
+		return nil, err
+	}
+	data, err := io.ReadAll(resp.Body)
+	_ = resp.Body.Close()
+	return data, err
+}
+
+const mediaHMACLength = 10
+
+func (cli *Client) downloadEncryptedMedia(url string, checksum []byte) (file, mac []byte, err error) {
+	data, err := cli.downloadMedia(url)
+	if err != nil {
+		return
+	} else if len(data) <= mediaHMACLength {
+		err = ErrTooShortFile
+		return
+	}
+	file, mac = data[:len(data)-mediaHMACLength], data[len(data)-mediaHMACLength:]
+	if len(checksum) == 32 && sha256.Sum256(data) != *(*[32]byte)(checksum) {
+		err = ErrInvalidMediaEncSHA256
+	}
+	return
+}
+
+func validateMedia(iv, file, macKey, mac []byte) error {
+	h := hmac.New(sha256.New, macKey)
+	h.Write(iv)
+	h.Write(file)
+	if !hmac.Equal(h.Sum(nil)[:mediaHMACLength], mac) {
+		return ErrInvalidMediaHMAC
+	}
+	return nil
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/errors.go

@@ -0,0 +1,260 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package whatsmeow
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+
+	waBinary "go.mau.fi/whatsmeow/binary"
+)
+
+// Miscellaneous errors
+var (
+	ErrClientIsNil     = errors.New("client is nil")
+	ErrNoSession       = errors.New("can't encrypt message for device: no signal session established")
+	ErrIQTimedOut      = errors.New("info query timed out")
+	ErrNotConnected    = errors.New("websocket not connected")
+	ErrNotLoggedIn     = errors.New("the store doesn't contain a device JID")
+	ErrMessageTimedOut = errors.New("timed out waiting for message send response")
+
+	ErrAlreadyConnected = errors.New("websocket is already connected")
+
+	ErrQRAlreadyConnected = errors.New("GetQRChannel must be called before connecting")
+	ErrQRStoreContainsID  = errors.New("GetQRChannel can only be called when there's no user ID in the client's Store")
+
+	ErrNoPushName = errors.New("can't send presence without PushName set")
+
+	ErrNoPrivacyToken = errors.New("no privacy token stored")
+
+	ErrAppStateUpdate = errors.New("server returned error updating app state")
+)
+
+// Errors that happen while confirming device pairing
+var (
+	ErrPairInvalidDeviceIdentityHMAC = errors.New("invalid device identity HMAC in pair success message")
+	ErrPairInvalidDeviceSignature    = errors.New("invalid device signature in pair success message")
+	ErrPairRejectedLocally           = errors.New("local PrePairCallback rejected pairing")
+)
+
+// PairProtoError is included in an events.PairError if the pairing failed due to a protobuf error.
+type PairProtoError struct {
+	Message  string
+	ProtoErr error
+}
+
+func (err *PairProtoError) Error() string {
+	return fmt.Sprintf("%s: %v", err.Message, err.ProtoErr)
+}
+
+func (err *PairProtoError) Unwrap() error {
+	return err.ProtoErr
+}
+
+// PairDatabaseError is included in an events.PairError if the pairing failed due to being unable to save the credentials to the device store.
+type PairDatabaseError struct {
+	Message string
+	DBErr   error
+}
+
+func (err *PairDatabaseError) Error() string {
+	return fmt.Sprintf("%s: %v", err.Message, err.DBErr)
+}
+
+func (err *PairDatabaseError) Unwrap() error {
+	return err.DBErr
+}
+
+var (
+	// ErrProfilePictureUnauthorized is returned by GetProfilePictureInfo when trying to get the profile picture of a user
+	// whose privacy settings prevent you from seeing their profile picture (status code 401).
+	ErrProfilePictureUnauthorized = errors.New("the user has hidden their profile picture from you")
+	// ErrProfilePictureNotSet is returned by GetProfilePictureInfo when the given user or group doesn't have a profile
+	// picture (status code 404).
+	ErrProfilePictureNotSet = errors.New("that user or group does not have a profile picture")
+	// ErrGroupInviteLinkUnauthorized is returned by GetGroupInviteLink if you don't have the permission to get the link (status code 401).
+	ErrGroupInviteLinkUnauthorized = errors.New("you don't have the permission to get the group's invite link")
+	// ErrNotInGroup is returned by group info getting methods if you're not in the group (status code 403).
+	ErrNotInGroup = errors.New("you're not participating in that group")
+	// ErrGroupNotFound is returned by group info getting methods if the group doesn't exist (status code 404).
+	ErrGroupNotFound = errors.New("that group does not exist")
+	// ErrInviteLinkInvalid is returned by methods that use group invite links if the invite link is malformed.
+	ErrInviteLinkInvalid = errors.New("that group invite link is not valid")
+	// ErrInviteLinkRevoked is returned by methods that use group invite links if the invite link was valid, but has been revoked and can no longer be used.
+	ErrInviteLinkRevoked = errors.New("that group invite link has been revoked")
+	// ErrBusinessMessageLinkNotFound is returned by ResolveBusinessMessageLink if the link doesn't exist or has been revoked.
+	ErrBusinessMessageLinkNotFound = errors.New("that business message link does not exist or has been revoked")
+	// ErrContactQRLinkNotFound is returned by ResolveContactQRLink if the link doesn't exist or has been revoked.
+	ErrContactQRLinkNotFound = errors.New("that contact QR link does not exist or has been revoked")
+	// ErrInvalidImageFormat is returned by SetGroupPhoto if the given photo is not in the correct format.
+	ErrInvalidImageFormat = errors.New("the given data is not a valid image")
+	// ErrMediaNotAvailableOnPhone is returned by DecryptMediaRetryNotification if the given event contains error code 2.
+	ErrMediaNotAvailableOnPhone = errors.New("media no longer available on phone")
+	// ErrUnknownMediaRetryError is returned by DecryptMediaRetryNotification if the given event contains an unknown error code.
+	ErrUnknownMediaRetryError = errors.New("unknown media retry error")
+	// ErrInvalidDisappearingTimer is returned by SetDisappearingTimer if the given timer is not one of the allowed values.
+	ErrInvalidDisappearingTimer = errors.New("invalid disappearing timer provided")
+)
+
+// Some errors that Client.SendMessage can return
+var (
+	ErrBroadcastListUnsupported = errors.New("sending to non-status broadcast lists is not yet supported")
+	ErrUnknownServer            = errors.New("can't send message to unknown server")
+	ErrRecipientADJID           = errors.New("message recipient must be a user JID with no device part")
+	ErrServerReturnedError      = errors.New("server returned error")
+	ErrInvalidInlineBotID       = errors.New("invalid inline bot ID")
+)
+
+type DownloadHTTPError struct {
+	*http.Response
+}
+
+func (dhe DownloadHTTPError) Error() string {
+	return fmt.Sprintf("download failed with status code %d", dhe.StatusCode)
+}
+
+func (dhe DownloadHTTPError) Is(other error) bool {
+	var otherDHE DownloadHTTPError
+	return errors.As(other, &otherDHE) && dhe.StatusCode == otherDHE.StatusCode
+}
+
+// Some errors that Client.Download can return
+var (
+	ErrMediaDownloadFailedWith403 = DownloadHTTPError{Response: &http.Response{StatusCode: 403}}
+	ErrMediaDownloadFailedWith404 = DownloadHTTPError{Response: &http.Response{StatusCode: 404}}
+	ErrMediaDownloadFailedWith410 = DownloadHTTPError{Response: &http.Response{StatusCode: 410}}
+	ErrNoURLPresent               = errors.New("no url present")
+	ErrFileLengthMismatch         = errors.New("file length does not match")
+	ErrTooShortFile               = errors.New("file too short")
+	ErrInvalidMediaHMAC           = errors.New("invalid media hmac")
+	ErrInvalidMediaEncSHA256      = errors.New("hash of media ciphertext doesn't match")
+	ErrInvalidMediaSHA256         = errors.New("hash of media plaintext doesn't match")
+	ErrUnknownMediaType           = errors.New("unknown media type")
+	ErrNothingDownloadableFound   = errors.New("didn't find any attachments in message")
+)
+
+var (
+	ErrOriginalMessageSecretNotFound = errors.New("original message secret key not found")
+	ErrNotEncryptedReactionMessage   = errors.New("given message isn't an encrypted reaction message")
+	ErrNotPollUpdateMessage          = errors.New("given message isn't a poll update message")
+)
+
+type wrappedIQError struct {
+	HumanError error
+	IQError    error
+}
+
+func (err *wrappedIQError) Error() string {
+	return err.HumanError.Error()
+}
+
+func (err *wrappedIQError) Is(other error) bool {
+	return errors.Is(other, err.HumanError)
+}
+
+func (err *wrappedIQError) Unwrap() error {
+	return err.IQError
+}
+
+func wrapIQError(human, iq error) error {
+	return &wrappedIQError{human, iq}
+}
+
+// IQError is a generic error container for info queries
+type IQError struct {
+	Code      int
+	Text      string
+	ErrorNode *waBinary.Node
+	RawNode   *waBinary.Node
+}
+
+// Common errors returned by info queries for use with errors.Is
+var (
+	ErrIQBadRequest          error = &IQError{Code: 400, Text: "bad-request"}
+	ErrIQNotAuthorized       error = &IQError{Code: 401, Text: "not-authorized"}
+	ErrIQForbidden           error = &IQError{Code: 403, Text: "forbidden"}
+	ErrIQNotFound            error = &IQError{Code: 404, Text: "item-not-found"}
+	ErrIQNotAllowed          error = &IQError{Code: 405, Text: "not-allowed"}
+	ErrIQNotAcceptable       error = &IQError{Code: 406, Text: "not-acceptable"}
+	ErrIQGone                error = &IQError{Code: 410, Text: "gone"}
+	ErrIQResourceLimit       error = &IQError{Code: 419, Text: "resource-limit"}
+	ErrIQLocked              error = &IQError{Code: 423, Text: "locked"}
+	ErrIQRateOverLimit       error = &IQError{Code: 429, Text: "rate-overlimit"}
+	ErrIQInternalServerError error = &IQError{Code: 500, Text: "internal-server-error"}
+	ErrIQServiceUnavailable  error = &IQError{Code: 503, Text: "service-unavailable"}
+	ErrIQPartialServerError  error = &IQError{Code: 530, Text: "partial-server-error"}
+)
+
+func parseIQError(node *waBinary.Node) error {
+	var err IQError
+	err.RawNode = node
+	val, ok := node.GetOptionalChildByTag("error")
+	if ok {
+		err.ErrorNode = &val
+		ag := val.AttrGetter()
+		err.Code = ag.OptionalInt("code")
+		err.Text = ag.OptionalString("text")
+	}
+	return &err
+}
+
+func (iqe *IQError) Error() string {
+	if iqe.Code == 0 {
+		if iqe.ErrorNode != nil {
+			return fmt.Sprintf("info query returned unknown error: %s", iqe.ErrorNode.XMLString())
+		} else if iqe.RawNode != nil {
+			return fmt.Sprintf("info query returned unexpected response: %s", iqe.RawNode.XMLString())
+		} else {
+			return "unknown info query error"
+		}
+	}
+	return fmt.Sprintf("info query returned status %d: %s", iqe.Code, iqe.Text)
+}
+
+func (iqe *IQError) Is(other error) bool {
+	otherIQE, ok := other.(*IQError)
+	if !ok {
+		return false
+	} else if iqe.Code != 0 && otherIQE.Code != 0 {
+		return otherIQE.Code == iqe.Code && otherIQE.Text == iqe.Text
+	} else if iqe.ErrorNode != nil && otherIQE.ErrorNode != nil {
+		return iqe.ErrorNode.XMLString() == otherIQE.ErrorNode.XMLString()
+	} else {
+		return false
+	}
+}
+
+// ElementMissingError is returned by various functions that parse XML elements when a required element is missing.
+type ElementMissingError struct {
+	Tag string
+	In  string
+}
+
+func (eme *ElementMissingError) Error() string {
+	return fmt.Sprintf("missing <%s> element in %s", eme.Tag, eme.In)
+}
+
+var ErrIQDisconnected = &DisconnectedError{Action: "info query"}
+
+// DisconnectedError is returned if the websocket disconnects before an info query or other request gets a response.
+type DisconnectedError struct {
+	Action string
+	Node   *waBinary.Node
+}
+
+func (err *DisconnectedError) Error() string {
+	return fmt.Sprintf("websocket disconnected before %s returned response", err.Action)
+}
+
+func (err *DisconnectedError) Is(other error) bool {
+	otherDisc, ok := other.(*DisconnectedError)
+	if !ok {
+		return false
+	}
+	return otherDisc.Action == err.Action
+}