�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fsphinx%2F'>sphinx</a>/</p><hr><h3>✏️ Editing: snippets_udf.cc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>//
// $Id: snippets_udf.cc 4522 2014-01-30 11:00:18Z tomat $
//

//
// Copyright (c) 2001-2014, Andrew Aksyonoff
// Copyright (c) 2008-2014, Sphinx Technologies Inc
// All rights reserved
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License. You should have
// received a copy of the GPL license along with this program; if you
// did not, you can find it at http://www.gnu.org/
//

#include &lt;my_global.h&gt;
#include &lt;string.h&gt;
#include &lt;assert.h&gt;

#ifndef _WIN32
#include &lt;sys/un.h&gt;
#include &lt;netdb.h&gt;
#else
#include &lt;winsock2.h&gt;
#endif

#include &lt;mysql_version.h&gt;

#if MYSQL_VERSION_ID&gt;=50515
#include &quot;sql_class.h&quot;
#include &quot;sql_array.h&quot;
#elif MYSQL_VERSION_ID&gt;50100
#include &quot;mysql_priv.h&quot;
#include &lt;mysql/plugin.h&gt;
#else
#include &quot;../mysql_priv.h&quot;
#endif

#include &lt;mysys_err.h&gt;
#include &lt;my_sys.h&gt;

#if MYSQL_VERSION_ID&gt;=50120
typedef uchar byte;
#endif

/// partially copy-pasted stuff that should be moved elsewhere

#ifdef UNALIGNED_RAM_ACCESS

/// pass-through wrapper
template &lt; typename T &gt; inline T sphUnalignedRead ( const T &amp; tRef )
{
	return tRef;
}

/// pass-through wrapper
template &lt; typename T &gt; void sphUnalignedWrite ( void * pPtr, const T &amp; tVal )
{
	*(T*)pPtr = tVal;
}

#else

/// unaligned read wrapper for some architectures (eg. SPARC)
template &lt; typename T &gt;
inline T sphUnalignedRead ( const T &amp; tRef )
{
	T uTmp;
	byte * pSrc = (byte *) &amp;tRef;
	byte * pDst = (byte *) &amp;uTmp;
	for ( int i=0; i&lt;(int)sizeof(T); i++ )
		*pDst++ = *pSrc++;
	return uTmp;
}

/// unaligned write wrapper for some architectures (eg. SPARC)
template &lt; typename T &gt;
void sphUnalignedWrite ( void * pPtr, const T &amp; tVal )
{
	byte * pDst = (byte *) pPtr;
	byte * pSrc = (byte *) &amp;tVal;
	for ( int i=0; i&lt;(int)sizeof(T); i++ )
		*pDst++ = *pSrc++;
}

#endif /* UNALIGNED_RAM_ACCESS */

#define SPHINXSE_MAX_ALLOC			(16*1024*1024)

#define SafeDelete(_arg)		{ if ( _arg ) delete ( _arg );		(_arg) = NULL; }
#define SafeDeleteArray(_arg)	{ if ( _arg ) delete [] ( _arg );	(_arg) = NULL; }

#define Min(a,b) ((a)&lt;(b)?(a):(b))
#ifndef _WIN32
typedef unsigned int DWORD;
#endif
inline DWORD sphF2DW ( float f ) { union { float f; uint32 d; } u; u.f = f; return u.d; }

static char * sphDup ( const char * sSrc, int iLen=-1 )
{
	if ( !sSrc )
		return NULL;

	if ( iLen&lt;0 )
		iLen = strlen(sSrc);

	char * sRes = new char [ 1+iLen ];
	memcpy ( sRes, sSrc, iLen );
	sRes[iLen] = &#039;\0&#039;;
	return sRes;
}

static inline void sphShowErrno ( const char * sCall )
{
	char sError[256];
	snprintf ( sError, sizeof(sError), &quot;%s() failed: [%d] %s&quot;, sCall, errno, strerror(errno) );
	my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), sError );
}

static const bool sphReportErrors = true;

static bool sphSend ( int iFd, const char * pBuffer, int iSize, bool bReportErrors = false )
{
	assert ( pBuffer );
	assert ( iSize &gt; 0 );

	const int iResult = send ( iFd, pBuffer, iSize, 0 );
	if ( iResult!=iSize )
	{
		if ( bReportErrors ) sphShowErrno(&quot;send&quot;);
		return false;
	}
	return true;
}

static bool sphRecv ( int iFd, char * pBuffer, int iSize, bool bReportErrors = false )
{
	assert ( pBuffer );
	assert ( iSize &gt; 0 );

	while ( iSize )
	{
		const int iResult = recv ( iFd, pBuffer, iSize, 0 );
		if ( iResult &gt; 0 )
		{
			iSize -= iResult;
			pBuffer += iSize;
		} else if ( iResult==0 )
		{
			if ( bReportErrors )
				my_error ( ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0), &quot;recv() failed: disconnected&quot; );
			return false;
		} else
		{
			if ( bReportErrors ) sphShowErrno(&quot;recv&quot;);
			return false;
		}
	}
	return true;
}

enum
{
	SPHINX_SEARCHD_PROTO		= 1,

	SEARCHD_COMMAND_EXCERPT		= 1,

	VER_COMMAND_EXCERPT		= 0x104,
};

/// known answers
enum
{
	SEARCHD_OK		= 0,	///&lt; general success, command-specific reply follows
	SEARCHD_ERROR	= 1,	///&lt; general failure, error message follows
	SEARCHD_RETRY	= 2,	///&lt; temporary failure, error message follows, client should retry later
	SEARCHD_WARNING	= 3		///&lt; general success, warning message and command-specific reply follow
};

#define SPHINXSE_DEFAULT_SCHEME		(char*) &quot;sphinx&quot;
#define SPHINXSE_DEFAULT_HOST		(char*) &quot;127.0.0.1&quot;
#define SPHINXSE_DEFAULT_PORT		9312
#define SPHINXSE_DEFAULT_INDEX		(char*) &quot;*&quot;

class CSphBuffer
{
private:
	bool m_bOverrun;
	int m_iSize;
	int m_iLeft;
	char * m_pBuffer;
	char * m_pCurrent;

public:
	explicit CSphBuffer ( const int iSize )
		: m_bOverrun ( false )
		, m_iSize ( iSize )
		, m_iLeft ( iSize )
	{
		assert ( iSize &gt; 0 );
		m_pBuffer = new char[iSize];
		m_pCurrent = m_pBuffer;
	}

	~CSphBuffer ()
	{
		SafeDeleteArray ( m_pBuffer );
	}

	const char * Ptr() const { return m_pBuffer; }

	bool Finalize()
	{
		return !( m_bOverrun || m_iLeft!=0 || ( m_pCurrent - m_pBuffer )!=m_iSize );
	}

	void SendBytes ( const void * pBytes, int iBytes );

	void SendWord ( short int v )					{ v = ntohs(v); SendBytes ( &amp;v, sizeof(v) ); } // NOLINT
	void SendInt ( int v )							{ v = ntohl(v); SendBytes ( &amp;v, sizeof(v) ); }
	void SendDword ( DWORD v )						{ v = ntohl(v) ;SendBytes ( &amp;v, sizeof(v) ); }
	void SendUint64 ( ulonglong v )					{ SendDword ( uint ( v&gt;&gt;32 ) ); SendDword ( uint ( v&amp;0xFFFFFFFFUL ) ); }
	void SendString ( const char * v )				{ SendString ( v, strlen(v) ); }
	void SendString ( const char * v, int iLen )	{ SendDword(iLen); SendBytes ( v, iLen ); }
	void SendFloat ( float v )						{ SendDword ( sphF2DW(v) ); }
};

void CSphBuffer::SendBytes ( const void * pBytes, int iBytes )
{
	if ( m_iLeft &lt; iBytes )
	{
		m_bOverrun = true;
		return;
	}

	memcpy ( m_pCurrent, pBytes, iBytes );

	m_pCurrent += iBytes;
	m_iLeft -= iBytes;
}

struct CSphUrl
{
	char * m_sBuffer;
	char * m_sFormatted;

	char * m_sScheme;
	char * m_sHost;
	char * m_sIndex;

	int m_iPort;

	CSphUrl()
		: m_sBuffer ( NULL )
		, m_sFormatted ( NULL )
		, m_sScheme ( SPHINXSE_DEFAULT_SCHEME )
		, m_sHost ( SPHINXSE_DEFAULT_HOST )
		, m_sIndex ( SPHINXSE_DEFAULT_INDEX )
		, m_iPort ( SPHINXSE_DEFAULT_PORT )
	{}

	~CSphUrl()
	{
		SafeDeleteArray ( m_sFormatted );
		SafeDeleteArray ( m_sBuffer );
	}

	bool Parse ( const char * sUrl, int iLen );
	int Connect();
	const char * Format();
};

const char * CSphUrl::Format()
{
	if ( !m_sFormatted )
	{
		int iSize = 15 + strlen(m_sHost) + strlen(m_sIndex);
		m_sFormatted = new char [ iSize ];
		if ( m_iPort )
			snprintf ( m_sFormatted, iSize, &quot;inet://%s:%d/%s&quot;, m_sHost, m_iPort, m_sIndex );
		else
			snprintf ( m_sFormatted, iSize, &quot;unix://%s/%s&quot;, m_sHost, m_sIndex );
	}
	return m_sFormatted;
}

// the following scheme variants are recognized
//
// inet://host/index
// inet://host:port/index
// unix://unix/domain/socket:index
// unix://unix/domain/socket
bool CSphUrl::Parse ( const char * sUrl, int iLen )
{
	bool bOk = true;
	while ( iLen )
	{
		bOk = false;

		m_sBuffer = sphDup ( sUrl, iLen );
		m_sScheme = m_sBuffer;

		m_sHost = strstr ( m_sBuffer, &quot;://&quot; );
		if ( !m_sHost )
			break;
		m_sHost[0] = &#039;\0&#039;;
		m_sHost += 2;

		if ( !strcmp ( m_sScheme, &quot;unix&quot; ) )
		{
			// unix-domain socket
			m_iPort = 0;
			if (!( m_sIndex = strrchr ( m_sHost, &#039;:&#039; ) ))
				m_sIndex = SPHINXSE_DEFAULT_INDEX;
			else
			{
				*m_sIndex++ = &#039;\0&#039;;
				if ( !*m_sIndex )
					m_sIndex = SPHINXSE_DEFAULT_INDEX;
			}
			bOk = true;
			break;
		}
		if ( strcmp ( m_sScheme, &quot;sphinx&quot; )!=0 &amp;&amp; strcmp ( m_sScheme, &quot;inet&quot; )!=0 )
			break;

		// inet
		m_sHost++;
		char * sPort = strchr ( m_sHost, &#039;:&#039; );
		if ( sPort )
		{
			*sPort++ = &#039;\0&#039;;
			if ( *sPort )
			{
				m_sIndex = strchr ( sPort, &#039;/&#039; );
				if ( m_sIndex )
					*m_sIndex++ = &#039;\0&#039;;
				else
					m_sIndex = SPHINXSE_DEFAULT_INDEX;

				m_iPort = atoi(sPort);
				if ( !m_iPort )
					m_iPort = SPHINXSE_DEFAULT_PORT;
			}
		} else
		{
			m_sIndex = strchr ( m_sHost, &#039;/&#039; );
			if ( m_sIndex )
				*m_sIndex++ = &#039;\0&#039;;
			else
				m_sIndex = SPHINXSE_DEFAULT_INDEX;
		}

		bOk = true;
		break;
	}

	return bOk;
}

int CSphUrl::Connect()
{
	struct sockaddr_in sin;
#ifndef _WIN32
	struct sockaddr_un saun;
#endif

	int iDomain = 0;
	int iSockaddrSize = 0;
	struct sockaddr * pSockaddr = NULL;

	in_addr_t ip_addr;

	if ( m_iPort )
	{
		iDomain = AF_INET;
		iSockaddrSize = sizeof(sin);
		pSockaddr = (struct sockaddr *) &amp;sin;

		memset ( &amp;sin, 0, sizeof(sin) );
		sin.sin_family = AF_INET;
		sin.sin_port = htons ( m_iPort );

		// resolve address
		if ( (int)( ip_addr = inet_addr ( m_sHost ) )!=(int)INADDR_NONE )
			memcpy ( &amp;sin.sin_addr, &amp;ip_addr, sizeof(ip_addr) );
		else
		{
			int tmp_errno;
			bool bError = false;

#if MYSQL_VERSION_ID&gt;=50515
			struct addrinfo *hp = NULL;
			tmp_errno = getaddrinfo ( m_sHost, NULL, NULL, &amp;hp );
			if ( !tmp_errno || !hp || !hp-&gt;ai_addr )
			{
				bError = true;
				if ( hp )
					freeaddrinfo ( hp );
			}
#else
			struct hostent tmp_hostent, *hp;
			char buff2 [ GETHOSTBYNAME_BUFF_SIZE ];
			hp = my_gethostbyname_r ( m_sHost, &amp;tmp_hostent, buff2, sizeof(buff2), &amp;tmp_errno );
			if ( !hp )
			{
				my_gethostbyname_r_free();
				bError = true;
			}
#endif

			if ( bError )
			{
				char sError[256];
				my_snprintf ( sError, sizeof(sError), &quot;failed to resolve searchd host (name=%s)&quot;, m_sHost );

				my_error ( ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0), sError );
				return -1;
			}

#if MYSQL_VERSION_ID&gt;=50515
			memcpy ( &amp;sin.sin_addr, hp-&gt;ai_addr, Min ( sizeof(sin.sin_addr), (size_t)hp-&gt;ai_addrlen ) );
			freeaddrinfo ( hp );
#else
			memcpy ( &amp;sin.sin_addr, hp-&gt;h_addr, Min ( sizeof(sin.sin_addr), (size_t)hp-&gt;h_length ) );
			my_gethostbyname_r_free();
#endif
		}
	} else
	{
#ifndef _WIN32
		iDomain = AF_UNIX;
		iSockaddrSize = sizeof(saun);
		pSockaddr = (struct sockaddr *) &amp;saun;

		memset ( &amp;saun, 0, sizeof(saun) );
		saun.sun_family = AF_UNIX;
		strncpy ( saun.sun_path, m_sHost, sizeof(saun.sun_path)-1 );
#else
		my_error ( ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0), &quot;Unix-domain sockets are not supported on Windows&quot; );
		return -1;
#endif
	}

	// connect to searchd and exchange versions
	uint uServerVersion;
	uint uClientVersion = htonl ( SPHINX_SEARCHD_PROTO );
	int iSocket = -1;
	const char * pError = NULL;
	do
	{
		iSocket = (int)socket ( iDomain, SOCK_STREAM, 0 );
		if ( iSocket==-1 )
		{
			pError = &quot;Failed to create client socket&quot;;
			break;
		}

		if ( connect ( iSocket, pSockaddr, iSockaddrSize )==-1 )
		{
			pError = &quot;Failed to connect to searchd&quot;;
			break;
		}

		if ( !sphRecv ( iSocket, (char *)&amp;uServerVersion, sizeof(uServerVersion) ) )
		{
			pError = &quot;Failed to receive searchd version&quot;;
			break;
		}

		if ( !sphSend ( iSocket, (char *)&amp;uClientVersion, sizeof(uClientVersion) ) )
		{
			pError = &quot;Failed to send client version&quot;;
			break;
		}
	}
	while(0);

	// fixme: compare versions?

	if ( pError )
	{
		char sError[1024];
		snprintf ( sError, sizeof(sError), &quot;%s [%d] %s&quot;, Format(), errno, strerror(errno) );
		my_error ( ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0), sError );

		if ( iSocket!=-1 )
			close ( iSocket );

		return -1;
	}

	return iSocket;
}

struct CSphResponse
{
	char * m_pBuffer;
	char * m_pBody;

	CSphResponse ()
		: m_pBuffer ( NULL )
		, m_pBody ( NULL )
	{}

	explicit CSphResponse ( DWORD uSize )
		: m_pBody ( NULL )
	{
		m_pBuffer = new char[uSize];
	}

	~CSphResponse ()
	{
		SafeDeleteArray ( m_pBuffer );
	}

	static CSphResponse * Read ( int iSocket, int iClientVersion );
};

CSphResponse *
CSphResponse::Read ( int iSocket, int iClientVersion )
{
	char sHeader[8];
	if ( !sphRecv ( iSocket, sHeader, sizeof(sHeader) ) )
		return NULL;

	int iStatus = ntohs ( sphUnalignedRead ( *(short int *) &amp;sHeader[0] ) );
	int iVersion = ntohs ( sphUnalignedRead ( *(short int *) &amp;sHeader[2] ) );
	DWORD uLength = ntohl ( sphUnalignedRead ( *(DWORD *)		&amp;sHeader[4] ) );

	if ( iVersion&lt;iClientVersion )
		return NULL;

	if ( uLength&lt;=SPHINXSE_MAX_ALLOC )
	{
		CSphResponse * pResponse = new CSphResponse ( uLength );
		if ( !sphRecv ( iSocket, pResponse-&gt;m_pBuffer, uLength ) )
		{
			SafeDelete ( pResponse );
			return NULL;
		}

		pResponse-&gt;m_pBody = pResponse-&gt;m_pBuffer;
		if ( iStatus!=SEARCHD_OK )
		{
			DWORD uSize = ntohl ( *(DWORD *)pResponse-&gt;m_pBuffer );
			if ( iStatus==SEARCHD_WARNING )
			{
				pResponse-&gt;m_pBody += uSize; // fixme: report the warning somehow
			} else
			{
				char * sMessage = sphDup ( pResponse-&gt;m_pBuffer + sizeof(DWORD), uSize );
				my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), sMessage );
				SafeDeleteArray ( sMessage );
				SafeDelete ( pResponse );
				return NULL;
			}
		}
		return pResponse;
	}
	return NULL;
}

/// udf
#ifdef _MSC_VER
#define DLLEXPORT __declspec(dllexport)
#else
#define DLLEXPORT 
#endif

extern &quot;C&quot;
{
	DLLEXPORT my_bool sphinx_snippets_init ( UDF_INIT * pUDF, UDF_ARGS * pArgs, char * sMessage );
	DLLEXPORT void sphinx_snippets_deinit ( UDF_INIT * pUDF );
	DLLEXPORT char * sphinx_snippets ( UDF_INIT * pUDF, UDF_ARGS * pArgs, char * sResult, unsigned long * pLength, char * pIsNull, char * sError );
};

#define MAX_MESSAGE_LENGTH 255
#define MAX_RESULT_LENGTH 255

struct CSphSnippets
{
	CSphUrl m_tUrl;
	CSphResponse * m_pResponse;

	int m_iBeforeMatch;
	int m_iAfterMatch;
	int m_iChunkSeparator;
	int m_iStripMode;
	int m_iPassageBoundary;
	int m_iLimit;
	int m_iLimitWords;
	int m_iLimitPassages;
	int m_iAround;
	int m_iPassageId;
	int m_iFlags;

	CSphSnippets()
		: m_pResponse(NULL)
		, m_iBeforeMatch(0)
		, m_iAfterMatch(0)
		, m_iChunkSeparator(0)
		, m_iStripMode(0)
		, m_iPassageBoundary(0)
		// defaults
		, m_iLimit(256)
		, m_iLimitWords(0)
		, m_iLimitPassages(0)
		, m_iAround(5)
		, m_iPassageId(1)
		, m_iFlags(1)
	{
	}

	~CSphSnippets()
	{
		SafeDelete ( m_pResponse );
	}
};

#define KEYWORD(NAME) else if ( strncmp ( NAME, pArgs-&gt;attributes[i], pArgs-&gt;attribute_lengths[i] )==0 )

#define CHECK_TYPE(TYPE)											\
	if ( pArgs-&gt;arg_type[i]!=TYPE )									\
	{																\
		snprintf ( sMessage, MAX_MESSAGE_LENGTH,					\
					&quot;%.*s argument must be a string&quot;,				\
					(int)pArgs-&gt;attribute_lengths[i],				\
					pArgs-&gt;attributes[i] );							\
		bFail = true;												\
		break;														\
	}																\
	if ( TYPE==STRING_RESULT &amp;&amp; !pArgs-&gt;args[i] )					\
	{																\
		snprintf ( sMessage, MAX_MESSAGE_LENGTH,					\
					&quot;%.*s argument must be constant (and not NULL)&quot;,	\
					(int)pArgs-&gt;attribute_lengths[i],				\
					pArgs-&gt;attributes[i] );							\
		bFail = true;												\
		break;														\
	}

#define STRING CHECK_TYPE(STRING_RESULT)
#define INT CHECK_TYPE(INT_RESULT); int iValue =(int)*(long long *)pArgs-&gt;args[i]

my_bool sphinx_snippets_init ( UDF_INIT * pUDF, UDF_ARGS * pArgs, char * sMessage )
{
	if ( pArgs-&gt;arg_count &lt; 3 )
	{
		strncpy ( sMessage, &quot;insufficient arguments&quot;, MAX_MESSAGE_LENGTH );
		return 1;
	}

	bool bFail = false;
	CSphSnippets * pOpts = new CSphSnippets;
	for ( uint i = 0; i &lt; pArgs-&gt;arg_count; i++ )
	{
		if ( i &lt; 3 )
		{
			if ( pArgs-&gt;arg_type[i]!=STRING_RESULT )
			{
				strncpy ( sMessage, &quot;first three arguments must be of string type&quot;, MAX_MESSAGE_LENGTH );
				bFail = true;
				break;
			}
		}
		KEYWORD(&quot;sphinx&quot;)
		{
			STRING;
			if ( !pOpts-&gt;m_tUrl.Parse ( pArgs-&gt;args[i], pArgs-&gt;lengths[i] ) )
			{
				strncpy ( sMessage, &quot;failed to parse connection string&quot;, MAX_MESSAGE_LENGTH );
				bFail = true;
				break;
			}
		}
		KEYWORD(&quot;before_match&quot;)		{ STRING; pOpts-&gt;m_iBeforeMatch = i; }
		KEYWORD(&quot;after_match&quot;)		{ STRING; pOpts-&gt;m_iAfterMatch = i; }
		KEYWORD(&quot;chunk_separator&quot;)	{ STRING; pOpts-&gt;m_iChunkSeparator = i; }
		KEYWORD(&quot;html_strip_mode&quot;)	{ STRING; pOpts-&gt;m_iStripMode = i; }
		KEYWORD(&quot;passage_boundary&quot;) { STRING; pOpts-&gt;m_iPassageBoundary = i; }

		KEYWORD(&quot;limit&quot;)			{ INT; pOpts-&gt;m_iLimit = iValue; }
		KEYWORD(&quot;limit_words&quot;)		{ INT; pOpts-&gt;m_iLimitWords = iValue; }
		KEYWORD(&quot;limit_passages&quot;)	{ INT; pOpts-&gt;m_iLimitPassages = iValue; }
		KEYWORD(&quot;around&quot;)			{ INT; pOpts-&gt;m_iAround = iValue; }
		KEYWORD(&quot;start_passage_id&quot;) { INT; pOpts-&gt;m_iPassageId = iValue; }

		KEYWORD(&quot;exact_phrase&quot;)		{ INT; if ( iValue ) pOpts-&gt;m_iFlags |= 2; }
		KEYWORD(&quot;single_passage&quot;)	{ INT; if ( iValue ) pOpts-&gt;m_iFlags |= 4; }
		KEYWORD(&quot;use_boundaries&quot;)	{ INT; if ( iValue ) pOpts-&gt;m_iFlags |= 8; }
		KEYWORD(&quot;weight_order&quot;)		{ INT; if ( iValue ) pOpts-&gt;m_iFlags |= 16; }
		KEYWORD(&quot;query_mode&quot;)		{ INT; if ( iValue ) pOpts-&gt;m_iFlags |= 32; }
		KEYWORD(&quot;force_all_words&quot;)	{ INT; if ( iValue ) pOpts-&gt;m_iFlags |= 64; }
		KEYWORD(&quot;load_files&quot;)		{ INT; if ( iValue ) pOpts-&gt;m_iFlags |= 128; }
		KEYWORD(&quot;allow_empty&quot;)		{ INT; if ( iValue ) pOpts-&gt;m_iFlags |= 256; }
		KEYWORD(&quot;emit_zones&quot;)		{ INT; if ( iValue ) pOpts-&gt;m_iFlags |= 512; }
		KEYWORD(&quot;load_files_scattered&quot;) { INT; if ( iValue ) pOpts-&gt;m_iFlags |= 1024; }
		else
		{
			snprintf ( sMessage, MAX_MESSAGE_LENGTH, &quot;unrecognized argument: %.*s&quot;,
						(int)pArgs-&gt;attribute_lengths[i], pArgs-&gt;attributes[i] );
			bFail = true;
			break;
		}
	}

	if ( bFail )
	{
		SafeDelete ( pOpts );
		return 1;
	}
	pUDF-&gt;ptr = (char *)pOpts;
	return 0;
}

#undef STRING
#undef INT
#undef KEYWORD
#undef CHECK_TYPE

#define ARG(i) pArgs-&gt;args[i], pArgs-&gt;lengths[i]
#define ARG_LEN(VAR, LEN) ( VAR ? pArgs-&gt;lengths[VAR] : LEN )

#define SEND_STRING(INDEX, DEFAULT)							\
	if ( INDEX )											\
		tBuffer.SendString ( ARG(INDEX) );					\
	else													\
		tBuffer.SendString ( DEFAULT, sizeof(DEFAULT) - 1 );


char * sphinx_snippets ( UDF_INIT * pUDF, UDF_ARGS * pArgs, char * sResult, unsigned long * pLength, char * pIsNull, char * pError )
{
	CSphSnippets * pOpts = (CSphSnippets *)pUDF-&gt;ptr;
	assert ( pOpts );

	if ( !pArgs-&gt;args[0] || !pArgs-&gt;args[1] || !pArgs-&gt;args[2] )
	{
		*pIsNull = 1;
		return sResult;
	}

	const int iSize = 68 +
		pArgs-&gt;lengths[1] + // index
		pArgs-&gt;lengths[2] + // words
		ARG_LEN ( pOpts-&gt;m_iBeforeMatch, 3 ) +
		ARG_LEN ( pOpts-&gt;m_iAfterMatch, 4 ) +
		ARG_LEN ( pOpts-&gt;m_iChunkSeparator, 5 ) +
		ARG_LEN ( pOpts-&gt;m_iStripMode, 5 ) +
		ARG_LEN ( pOpts-&gt;m_iPassageBoundary, 0 ) +
		4 + pArgs-&gt;lengths[0]; // document

	CSphBuffer tBuffer(iSize);

	tBuffer.SendWord ( SEARCHD_COMMAND_EXCERPT );
	tBuffer.SendWord ( VER_COMMAND_EXCERPT );
	tBuffer.SendDword ( iSize - 8 );

	tBuffer.SendDword ( 0 );
	tBuffer.SendDword ( pOpts-&gt;m_iFlags );

	tBuffer.SendString ( ARG(1) ); // index
	tBuffer.SendString ( ARG(2) ); // words

	SEND_STRING ( pOpts-&gt;m_iBeforeMatch, &quot;&lt;b&gt;&quot; );
	SEND_STRING ( pOpts-&gt;m_iAfterMatch, &quot;&lt;/b&gt;&quot; );
	SEND_STRING ( pOpts-&gt;m_iChunkSeparator, &quot; ... &quot; );

	tBuffer.SendInt ( pOpts-&gt;m_iLimit );
	tBuffer.SendInt ( pOpts-&gt;m_iAround );

	tBuffer.SendInt ( pOpts-&gt;m_iLimitPassages );
	tBuffer.SendInt ( pOpts-&gt;m_iLimitWords );
	tBuffer.SendInt ( pOpts-&gt;m_iPassageId );

	SEND_STRING ( pOpts-&gt;m_iStripMode, &quot;index&quot; );
	SEND_STRING ( pOpts-&gt;m_iPassageBoundary, &quot;&quot; );

	// single document
	tBuffer.SendInt ( 1 );
	tBuffer.SendString ( ARG(0) );

	int iSocket = -1;
	do
	{
		if ( !tBuffer.Finalize() )
		{
			my_error ( ER_QUERY_ON_FOREIGN_DATA_SOURCE, MYF(0), &quot;INTERNAL ERROR: failed to build request&quot; );
			break;
		}

		iSocket = pOpts-&gt;m_tUrl.Connect();
		if ( iSocket==-1 ) break;
		if ( !sphSend ( iSocket, tBuffer.Ptr(), iSize, sphReportErrors ) ) break;

		CSphResponse * pResponse = CSphResponse::Read ( iSocket, VER_COMMAND_EXCERPT );
		if ( !pResponse ) break;

		close ( iSocket );
		pOpts-&gt;m_pResponse = pResponse;
		*pLength = ntohl ( *(DWORD *)pResponse-&gt;m_pBody );
		return pResponse-&gt;m_pBody + sizeof(DWORD);
	}
	while(0);

	if ( iSocket!=-1 )
		close ( iSocket );

	*pError = 1;
	return sResult;
}

#undef SEND_STRING
#undef ARG_LEN
#undef ARG

void sphinx_snippets_deinit ( UDF_INIT * pUDF )
{
	CSphSnippets * pOpts = (CSphSnippets *)pUDF-&gt;ptr;
	SafeDelete ( pOpts );
}

//
// $Id: snippets_udf.cc 4522 2014-01-30 11:00:18Z tomat $
//
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fsphinx'>🔙 Back</a></p>